Merge branch 'master' into qchem

Author: slipchenko

EFP2.C

@@ -0,0 +1,125 @@
+#ifndef EFP2_H_INCLUDED
+#define EFP2_H_INCLUDED
+
+#include <vector>
+
+class EFP2_impl;
+class InputSection;
+
+class EFP2 {
+public:
+	/* Initialize EFP2 instance using user's input. */
+	void init(InputSection &);
+
+	/* Returns true if the current EFP2 instance was initialized. */
+	bool initialized();
+
+    /* Returns if_multipole_field value. */
+    bool get_if_multipole_field();
+
+    /* Returns updated if_multipole_field value. */
+    void update_multipole_field();
+
+    /* Returns if_pol_field value. */
+    bool get_if_pol_field();
+
+    /* Returns updated if_pol_field value. */
+    void update_pol_field();
+
+	/* Reorient EFP fragments according to Q-Chem's orientation of
+	 * ab initio subsystem. */
+	void reorient_geometry();
+
+	/* Print geometry of EFP subsystem. */
+	void print_geometry();
+
+	/* Setup all necessary stuff for AI/EFP dispersion computation
+	 * if enabled */
+	void setup_aiefp_dispersion();
+
+	/* Compute all EFP and the rest of QM/EFP interactions after
+	 * the QM SCF has converged.
+	 * \p do_grad - specifies whether to compute the gradient.
+	 * If \p do_grad is not zero than the gradient will also be
+	 * computed. */
+	void compute(int do_grad);
+
+    /* Update quantum mechanical Hamiltonian with the contributions
+ * from EFP multipoles and atoms using AOints.
+ * \p h - a Hamiltonian matrix.
+ * \p code - Q-Chem's ShlPrs code. */
+    void update_mult_ints(double *h, INTEGER code);
+
+    /* Update quantum mechanical Hamiltonian with the contributions
+ * from EFP induced diples using AOints.
+ * \p h - a Hamiltonian matrix.
+ * \p code - Q-Chem's ShlPrs code. */
+    void update_pol_ints(double *h, INTEGER code);
+
+    /* Update quantum mechanical Hamiltonian with the contributions
+	 * from EFPs using AOints.
+	 * \p h - a Hamiltonian matrix.
+	 * \p code - Q-Chem's ShlPrs code. */
+	// void update_wf(double *h, INTEGER code);
+
+	/* Update quantum mechanical Hamiltonian with the contributions
+	 * from EFPs using libqints.
+	 * \p h - a Hamiltonian matrix.
+	 * \p code - Q-Chem's ShlPrs code. */
+	void update_wf_qints(double *h, INTEGER code);
+
+	/* Update the positions of quantum nuclei for libefp. */
+	void update_qm_atoms();
+
+	/* Returns the wavefunction dependent energy.
+	 * \p w - is a density matrix.
+	 * \p n - is a total number of elements in array \p w. */
+	double get_wf_dependent_energy(double *w, double n);
+
+	/* Returns the total EFP energy. */
+	double get_total_energy();
+
+	/* Returns EFP correction to the energy of the excited state.
+	 * \p w - is the density matrix of the excited state WF.
+	 * \p n - is the total number of elements in array \p w.
+	 * \p Ecis - excitation energy */
+	double get_excited_state_energy_correction(double *w, size_t n, double Ecis);
+
+    /* Returns gradient on quantum nuclei from EFP electrostatics.
+	 * Upon return the \p a vector will contain 3*N elements of
+	 * gradient, where N is the number of QM atoms. */
+	void get_qm_gradient(std::vector<double> &a);
+
+	/* Returns current EFP gradient.
+	 * The vector \p a will contain 6*N gradient values for
+	 * fragment translation and rotation. N is the total number of
+	 * EFP fragments. */
+	void get_gradient(std::vector<double> &a);
+
+    /* computes pairwise energies between QM region and EFP fragments.
+     *  \p Escf - reference AI energy (HF or excitation energy)
+     *  \p if_excited = 1/0 a switch to distinguish between the ground state (0) or excited state (1). */
+    void get_pairwise_energy(double Estate, int if_excited);
+
+	/* Print EFP energy terms to stdout. */
+	void print_energy();
+
+    /* Print pairwise energy decomposition to stdout.
+     * \p if_excited = 1/0 a switch to distinguish between the ground state (0) or excited state (1). */
+    void print_pairwise_energy(int if_excited);
+
+    /* Returns a EFP2 singleton instance. */
+	static EFP2& instance() {
+		static EFP2 instance;
+		return instance;
+	}
+
+private:
+	EFP2();
+	EFP2(const EFP2 &);
+	~EFP2();
+
+	EFP2_impl *impl_;
+};
+
+#endif /* EFP2_H_INCLUDED */

EFP2.h

@@ -7,11 +7,9 @@ molecular systems by replacing chemically inert part of a system by a set of
 Effective Fragments while performing regular _ab initio_ calculation on the
 chemically active part [1-8]. The LIBEFP library is a full implementation of
 the EFP method. It allows users to easily incorporate EFP support into their
-favourite quantum chemistry package. LIBEFP is used by many major quantum
-chemistry packages, such as [Q-Chem](http://www.q-chem.com),
-[PSI4](http://www.psicode.org), [NWChem](http://www.nwchem-sw.org),
-[GAMESS](http://www.msg.ameslab.gov/GAMESS),
-[Molcas](https://gitlab.com/Molcas), and others.
+favourite quantum chemistry package. 
+LIBEFP is interfaced to [Q-Chem](http://www.q-chem.com) and
+[PSI4](http://www.psicode.org) for QM/EFP calculations.
 
 Detailed description of methods and algorithms can be found in two LIBEFP
 papers:
@@ -69,7 +67,7 @@ For CMake instructions, see [README-cmake.md](README-cmake.md).
 ## Documentation
 
 The description of public LIBEFP API is available
-[here](https://ilyak.github.io/libefp/doxygen_html/efp_8h.html).
+[here](https://libefp2.github.io/doxygen_html/index.html).
 Also see [this](interface/readme.txt) file for step-by-step instructions.
 Fortran bindings to LIBEFP are available in
 [interface/efp.f90](interface/efp.f90).

README.md

@@ -0,0 +1,44 @@
+          RUNTYP=MAKEFP EFFECTIVE FRAGMENT POTENTIAL DATA FOLLOWS...
+          FRAGNAMEEFP GENERATED AT Tue Mar 27 16:14:27 2012
+ $H2O_REDUCED_L
+EFP DATA FOR FRAGNAME SCFTYP=RHF   ... GENERATED WITH BASIS SET=6-311++G(3df,2p)
+ COORDINATES (BOHR)
+A01O1      0.0000000000   0.1191094785   0.0000000000  15.9949100  8.0
+A02H2     -1.4223059670  -0.9451766865   0.0000000000   1.0078250  1.0
+A03H3      1.4223059670  -0.9451766865   0.0000000000   1.0078250  1.0
+BO21      -0.7111529835  -0.4130336040   0.0000000000   0.0000000  0.0
+BO31       0.7111529835  -0.4130336040   0.0000000000   0.0000000  0.0
+ STOP
+ MONOPOLES 
+A01O1     -8.4173680991   8.00000
+A02H2     -0.3512187169   1.00000
+A03H3     -0.3512187169   1.00000
+BO21      -0.4400972335   0.00000
+BO31      -0.4400972335   0.00000
+ STOP
+ DIPOLES 
+A01O1       0.0000000000   -0.4127062480    0.0000000000
+A02H2      -0.0027268078   -0.0014022974    0.0000000000
+A03H3       0.0027268078   -0.0014022974    0.0000000000
+BO21        0.2657818726    0.2358863756    0.0000000000
+BO31       -0.2657818726    0.2358863756    0.0000000000
+ STOP
+ POLARIZABLE POINTS
+CT1  -0.7491370634  -0.4890369778   0.0000000020
+    2.6629294234    1.7670590537    0.7812922107    1.2832534969 >
+   -0.0000000037   -0.0000000033    1.1482095947   -0.0000000144 >
+   -0.0000000132
+CT2   0.7491370628  -0.4890369781   0.0000000040
+    2.6629294254    1.7670590567    0.7812922113   -1.2832535009 >
+    0.0000000076   -0.0000000067   -1.1482095971    0.0000000195 >
+   -0.0000000177
+CT3   0.0000000011   0.3892153728  -0.4957986131
+    1.4502428775    1.8574126776    2.7113709049    0.0000000046 >
+   -0.0000000029   -0.9972382204    0.0000000048   -0.0000000034 >
+   -1.0913249895
+CT4  -0.0000000005   0.3892153799   0.4957986071
+    1.4502428978    1.8574127185    2.7113708742   -0.0000000023 >
+   -0.0000000009    0.9972382303   -0.0000000024   -0.0000000017 >
+    1.0913250020
+ STOP
+ $END

fraglib/h2o_reduced.efp

@@ -1415,6 +1415,36 @@ efp_get_frag_multipole_count(struct efp *efp, size_t frag_idx, size_t *n_mult)
 	return EFP_RESULT_SUCCESS;
 }
 
+/*
+EFP_EXPORT enum efp_result
+efp_get_frag_rank(struct efp *efp, size_t frag_idx, size_t *rank)
+{
+    assert(efp);
+    assert(rank);
+    assert(frag_idx < efp->n_frag);
+
+    struct frag *frag = efp->frags + frag_idx;
+
+    *rank = 0;
+    for (size_t i=0; i<frag->n_multipole_pts; i++) {
+        struct multipole_pt *pt = frag->multipole_pts + i;
+        size_t rank_tmp = 0;
+        if (pt->if_dip)
+            rank_tmp = 1;
+        if (pt->if_quad)
+            rank_tmp = 2;
+        if (pt->if_oct)
+            rank_tmp = 3;
+        if (rank_tmp > *rank)
+            *rank = rank_tmp;
+        if (*rank == 3)
+            break;
+    }
+
+    return EFP_RESULT_SUCCESS;
+}
+*/
+
 EFP_EXPORT enum efp_result
 efp_get_frag_rank(struct efp *efp, size_t frag_idx, size_t *rank)
 {
@@ -1634,7 +1664,6 @@ efp_get_induced_dipole_conj_values(struct efp *efp, double *dip)
 
     for (size_t i = 0; i < efp->n_frag; i++) {
         struct frag *frag = efp->frags + i;
-
         for (size_t j = 0; j < frag->n_polarizable_pts; j++) {
             struct polarizable_pt *pt = frag->polarizable_pts + j;
 
@@ -2465,7 +2494,6 @@ print_frag_info(struct efp *efp, size_t frag_index) {
     }
 
     print_ligand(efp, frag_index);
-
     printf("\n");
 }
 

src/efp.c

@@ -840,6 +840,16 @@ enum efp_result efp_get_frag_multipole_count(struct efp *efp, size_t frag_idx,
 enum efp_result efp_get_frag_multipole_coord(struct efp *efp, size_t frag_idx,
                                              size_t *n_mult);
 
+/**
+ * Computes multipole rank of a fragment
+ * @param efp
+ * @param[in] frag_idx fragment index
+ * @param[out] rank Highest rank of multipoles in the fragment
+ * (0 - charge, 1 - dipole, 2 - quad, 3 - oct)
+ * @return ::EFP_RESULT_SUCCESS on success or error code otherwise.
+ */
+// enum efp_result efp_get_frag_mult_rank(struct efp *efp, size_t frag_idx, size_t mult_idx, size_t *rank);
+
 /**
  * Computes multipole rank of a fragment
  * @param efp
@@ -1481,7 +1491,6 @@ void print_ene(struct efp_energy *energy);
  */
 void print_energies(struct efp *efp);
 
-
 #ifdef __cplusplus
 } /* extern "C" */
 #endif