Reduce verbosity of Green's functions instantiation in tests

Author: Roberto Di Remigio

src/bi_operators/CollocationIntegrator.hpp

@@ -73,7 +73,7 @@ struct CollocationIntegrator
     Eigen::MatrixXd singleLayer(const Vacuum<DerivativeTraits, CollocationIntegrator> & gf, const std::vector<Element> & e) const {
         return integrator::singleLayer(e,
                 pcm::bind(integrator::SI, this->factor, 1.0, pcm::_1),
-                pcm::bind(&Vacuum<DerivativeTraits, CollocationIntegrator>::kernelS, gf, pcm::_1, pcm::_2));
+                gf.exportKernelS());
     }
     /*! \tparam DerivativeTraits how the derivatives of the Greens's function are calculated
      *  \param[in] gf Green's function
@@ -83,7 +83,7 @@ struct CollocationIntegrator
     Eigen::MatrixXd doubleLayer(const Vacuum<DerivativeTraits, CollocationIntegrator> & gf, const std::vector<Element> & e) const {
         return integrator::doubleLayer(e,
                                        pcm::bind(integrator::DI, this->factor, pcm::_1),
-                                       pcm::bind(&Vacuum<DerivativeTraits, CollocationIntegrator>::kernelD, gf, pcm::_1, pcm::_2, pcm::_3));
+                                       gf.exportKernelD());
     }
     /**@}*/
 
@@ -96,7 +96,7 @@ struct CollocationIntegrator
     Eigen::MatrixXd singleLayer(const UniformDielectric<DerivativeTraits, CollocationIntegrator> & gf, const std::vector<Element> & e) const {
         return integrator::singleLayer(e,
                 pcm::bind(integrator::SI, this->factor, gf.epsilon(), pcm::_1),
-                pcm::bind(&UniformDielectric<DerivativeTraits, CollocationIntegrator>::kernelS, gf, pcm::_1, pcm::_2));
+                gf.exportKernelS());
     }
     /*! \tparam DerivativeTraits how the derivatives of the Greens's function are calculated
      *  \param[in] gf Green's function
@@ -106,7 +106,7 @@ struct CollocationIntegrator
     Eigen::MatrixXd doubleLayer(const UniformDielectric<DerivativeTraits, CollocationIntegrator> & gf, const std::vector<Element> & e) const {
         return integrator::doubleLayer(e,
                                        pcm::bind(integrator::DI, this->factor, pcm::_1),
-                                       pcm::bind(&UniformDielectric<DerivativeTraits, CollocationIntegrator>::kernelD, gf, pcm::_1, pcm::_2, pcm::_3));
+                                       gf.exportKernelD());
     }
     /**@}*/
 

src/bi_operators/IntegratorTypes.hpp

@@ -2,22 +2,22 @@
 /*
  *     PCMSolver, an API for the Polarizable Continuum Model
  *     Copyright (C) 2013-2015 Roberto Di Remigio, Luca Frediani and contributors
- *     
+ *
  *     This file is part of PCMSolver.
- *     
+ *
  *     PCMSolver is free software: you can redistribute it and/or modify
  *     it under the terms of the GNU Lesser General Public License as published by
  *     the Free Software Foundation, either version 3 of the License, or
  *     (at your option) any later version.
- *     
+ *
  *     PCMSolver is distributed in the hope that it will be useful,
  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *     GNU Lesser General Public License for more details.
- *     
+ *
  *     You should have received a copy of the GNU Lesser General Public License
  *     along with PCMSolver.  If not, see <http://www.gnu.org/licenses/>.
- *     
+ *
  *     For information on the complete list of contributors to the
  *     PCMSolver API, see: <http://pcmsolver.readthedocs.org/>
  */

src/bi_operators/NumericalIntegrator.hpp

@@ -63,7 +63,7 @@ struct NumericalIntegrator
      */
     template <typename DerivativeTraits>
     Eigen::MatrixXd singleLayer(const Vacuum<DerivativeTraits, NumericalIntegrator> & gf, const std::vector<Element> & e) const {
-        integrator::KernelS kernelS = pcm::bind(&Vacuum<DerivativeTraits, NumericalIntegrator>::kernelS, gf, pcm::_1, pcm::_2);
+        integrator::KernelS kernelS = gf.exportKernelS();
         integrator::Diagonal diagS = pcm::bind(&integrator::integrateS<32, 16>, kernelS, pcm::_1);
         return integrator::singleLayer(e, diagS, kernelS);
     }
@@ -73,7 +73,7 @@ struct NumericalIntegrator
      */
     template <typename DerivativeTraits>
     Eigen::MatrixXd doubleLayer(const Vacuum<DerivativeTraits, NumericalIntegrator> & gf, const std::vector<Element> & e) const {
-        integrator::KernelD kernelD = pcm::bind(&Vacuum<DerivativeTraits, NumericalIntegrator>::kernelD, gf, pcm::_1, pcm::_2, pcm::_3);
+        integrator::KernelD kernelD = gf.exportKernelD();
         integrator::Diagonal diagD = pcm::bind(&integrator::integrateD<32, 16>, kernelD, pcm::_1);
         return integrator::doubleLayer(e, diagD, kernelD);
     }
@@ -86,7 +86,7 @@ struct NumericalIntegrator
      */
     template <typename DerivativeTraits>
     Eigen::MatrixXd singleLayer(const UniformDielectric<DerivativeTraits, NumericalIntegrator> & gf, const std::vector<Element> & e) const {
-        integrator::KernelS kernelS = pcm::bind(&UniformDielectric<DerivativeTraits, NumericalIntegrator>::kernelS, gf, pcm::_1, pcm::_2);
+        integrator::KernelS kernelS = gf.exportKernelS();
         integrator::Diagonal diagS = pcm::bind(&integrator::integrateS<32, 16>, kernelS, pcm::_1);
         return integrator::singleLayer(e, diagS, kernelS);
     }
@@ -96,7 +96,7 @@ struct NumericalIntegrator
      */
     template <typename DerivativeTraits>
     Eigen::MatrixXd doubleLayer(const UniformDielectric<DerivativeTraits, NumericalIntegrator> & gf, const std::vector<Element> & e) const {
-        integrator::KernelD kernelD = pcm::bind(&UniformDielectric<DerivativeTraits, NumericalIntegrator>::kernelD, gf, pcm::_1, pcm::_2, pcm::_3);
+        integrator::KernelD kernelD = gf.exportKernelD();
         integrator::Diagonal diagD = pcm::bind(&integrator::integrateD<32, 16>, kernelD, pcm::_1);
         return integrator::doubleLayer(e, diagD, kernelD);
     }
@@ -109,7 +109,7 @@ struct NumericalIntegrator
      */
     template <typename DerivativeTraits>
     Eigen::MatrixXd singleLayer(const IonicLiquid<DerivativeTraits, NumericalIntegrator> & gf, const std::vector<Element> & e) const {
-        integrator::KernelS kernelS = pcm::bind(&IonicLiquid<DerivativeTraits, NumericalIntegrator>::kernelS, gf, pcm::_1, pcm::_2);
+        integrator::KernelS kernelS = gf.exportKernelS();
         integrator::Diagonal diagS = pcm::bind(&integrator::integrateS<32, 16>, kernelS, pcm::_1);
         return integrator::singleLayer(e, diagS, kernelS);
     }
@@ -119,7 +119,7 @@ struct NumericalIntegrator
      */
     template <typename DerivativeTraits>
     Eigen::MatrixXd doubleLayer(const IonicLiquid<DerivativeTraits, NumericalIntegrator> & gf, const std::vector<Element> & e) const {
-        integrator::KernelD kernelD = pcm::bind(&IonicLiquid<DerivativeTraits, NumericalIntegrator>::kernelD, gf, pcm::_1, pcm::_2, pcm::_3);
+        integrator::KernelD kernelD = gf.exportKernelD();
         integrator::Diagonal diagD = pcm::bind(&integrator::integrateD<32, 16>, kernelD, pcm::_1);
         return integrator::doubleLayer(e, diagD, kernelD);
     }
@@ -132,7 +132,7 @@ struct NumericalIntegrator
      */
     template <typename DerivativeTraits>
     Eigen::MatrixXd singleLayer(const AnisotropicLiquid<DerivativeTraits, NumericalIntegrator> & gf, const std::vector<Element> & e) const {
-        integrator::KernelS kernelS = pcm::bind(&AnisotropicLiquid<DerivativeTraits, NumericalIntegrator>::kernelS, gf, pcm::_1, pcm::_2);
+        integrator::KernelS kernelS = gf.exportKernelS();
         integrator::Diagonal diagS = pcm::bind(&integrator::integrateS<32, 16>, kernelS, pcm::_1);
         return integrator::singleLayer(e, diagS, kernelS);
     }
@@ -142,7 +142,7 @@ struct NumericalIntegrator
      */
     template <typename DerivativeTraits>
     Eigen::MatrixXd doubleLayer(const AnisotropicLiquid<DerivativeTraits, NumericalIntegrator> & gf, const std::vector<Element> & e) const {
-        integrator::KernelD kernelD = pcm::bind(&AnisotropicLiquid<DerivativeTraits, NumericalIntegrator>::kernelD, gf, pcm::_1, pcm::_2, pcm::_3);
+        integrator::KernelD kernelD = gf.exportKernelD();
         integrator::Diagonal diagD = pcm::bind(&integrator::integrateD<32, 16>, kernelD, pcm::_1);
         return integrator::doubleLayer(e, diagD, kernelD);
     }

src/bi_operators/PurisimaIntegrator.hpp

@@ -77,7 +77,7 @@ struct PurisimaIntegrator
     Eigen::MatrixXd singleLayer(const Vacuum<DerivativeTraits, PurisimaIntegrator> & gf, const std::vector<Element> & e) const {
         return integrator::singleLayer(e,
                 pcm::bind(integrator::SI, this->factor, 1.0, pcm::_1),
-                pcm::bind(&Vacuum<DerivativeTraits, PurisimaIntegrator>::kernelS, gf, pcm::_1, pcm::_2));
+                gf.exportKernelS());
     }
     /*! \tparam DerivativeTraits how the derivatives of the Greens's function are calculated
      *  \param[in] gf Green's function
@@ -86,7 +86,7 @@ struct PurisimaIntegrator
     template <typename DerivativeTraits>
     Eigen::MatrixXd doubleLayer(const Vacuum<DerivativeTraits, PurisimaIntegrator> & gf, const std::vector<Element> & e) const {
         // Obtain off-diagonal first
-        Eigen::MatrixXd D = offDiagonalD(e, pcm::bind(&Vacuum<DerivativeTraits, PurisimaIntegrator>::kernelD, gf, pcm::_1, pcm::_2, pcm::_3));
+        Eigen::MatrixXd D = offDiagonalD(e, gf.exportKernelD());
         // Fill diagonal based on Purisima's formula
         Eigen::VectorXd D_diag = diagonalD(e, D);
         D.diagonal() = D_diag;
@@ -103,7 +103,7 @@ struct PurisimaIntegrator
     Eigen::MatrixXd singleLayer(const UniformDielectric<DerivativeTraits, PurisimaIntegrator> & gf, const std::vector<Element> & e) const {
         return integrator::singleLayer(e,
                 pcm::bind(integrator::SI, this->factor, gf.epsilon(), pcm::_1),
-                pcm::bind(&UniformDielectric<DerivativeTraits, PurisimaIntegrator>::kernelS, gf, pcm::_1, pcm::_2));
+                gf.exportKernelS());
     }
     /*! \tparam DerivativeTraits how the derivatives of the Greens's function are calculated
      *  \param[in] gf Green's function
@@ -112,7 +112,7 @@ struct PurisimaIntegrator
     template <typename DerivativeTraits>
     Eigen::MatrixXd doubleLayer(const UniformDielectric<DerivativeTraits, PurisimaIntegrator> & gf, const std::vector<Element> & e) const {
         // Obtain off-diagonal first
-        Eigen::MatrixXd D = offDiagonalD(e, pcm::bind(&UniformDielectric<DerivativeTraits, PurisimaIntegrator>::kernelD, gf, pcm::_1, pcm::_2, pcm::_3));
+        Eigen::MatrixXd D = offDiagonalD(e, gf.exportKernelD());
         // Fill diagonal based on Purisima's formula
         Eigen::VectorXd D_diag = diagonalD(e, D);
         D.diagonal() = D_diag;

src/green/AnisotropicLiquid.hpp

@@ -36,6 +36,9 @@
 
 class Element;
 
+#include "DerivativeTypes.hpp"
+#include "DerivativeUtils.hpp"
+#include "bi_operators/IntegratorForward.hpp"
 #include "dielectric_profile/Anisotropic.hpp"
 #include "GreensFunction.hpp"
 
@@ -48,8 +51,8 @@ class Element;
  *  \tparam IntegratorPolicy policy for the calculation of the matrix represenation of S and D
  */
 
-template <typename DerivativeTraits,
-          typename IntegratorPolicy>
+template <typename DerivativeTraits = AD_directional,
+          typename IntegratorPolicy = CollocationIntegrator>
 class AnisotropicLiquid __final : public GreensFunction<DerivativeTraits, IntegratorPolicy, Anisotropic,
                                      AnisotropicLiquid<DerivativeTraits, IntegratorPolicy> >
 {
@@ -125,6 +128,12 @@ class AnisotropicLiquid __final : public GreensFunction<DerivativeTraits, Integr
         Eigen::Vector3d scratch = this->profile_.epsilon() * (this->gradientProbe(p1, p2));
         return scratch.dot(direction);
     }
+    virtual KernelS exportKernelS_impl() const __override {
+      return pcm::bind(&AnisotropicLiquid<DerivativeTraits, IntegratorPolicy>::kernelS, *this, pcm::_1, pcm::_2);
+    }
+    virtual KernelD exportKernelD_impl() const __override {
+      return pcm::bind(&AnisotropicLiquid<DerivativeTraits, IntegratorPolicy>::kernelD, *this, pcm::_1, pcm::_2, pcm::_3);
+    }
     virtual std::ostream & printObject(std::ostream & os) __override
     {
         os << "Green's function type: anisotropic liquid" << std::endl;

src/green/IGreensFunction.hpp

@@ -48,17 +48,27 @@ class Element;
  *  them.
  */
 
+/*! \typedef KernelS
+ *  \brief functor handle to the kernelS method
+ */
+typedef pcm::function<double(const Eigen::Vector3d &, const Eigen::Vector3d &)> KernelS;
+
+/*! \typedef KernelD
+ *  \brief functor handle to the kernelD method
+ */
+typedef pcm::function<double(const Eigen::Vector3d &, const Eigen::Vector3d &, const Eigen::Vector3d &)> KernelD;
+
 class IGreensFunction
 {
-public:
+  public:
     virtual ~IGreensFunction() {}
     /*! Returns value of the kernel of the \f$\mathcal{S}\f$ integral operator, i.e. the value of the
      *  Greens's function for the pair of points p1, p2: \f$ G(\mathbf{p}_1, \mathbf{p}_2)\f$
      *  \param[in] p1 first point
      *  \param[in] p2 second point
      */
     double kernelS(const Eigen::Vector3d & p1, const Eigen::Vector3d &p2) const {
-        return kernelS_impl(p1, p2);
+      return kernelS_impl(p1, p2);
     }
     /*! Returns value of the kernel of the \f$\mathcal{D}\f$ integral operator for the pair of points p1, p2:
      *  \f$ [\boldsymbol{\varepsilon}\nabla_{\mathbf{p_2}}G(\mathbf{p}_1, \mathbf{p}_2)]\cdot \mathbf{n}_{\mathbf{p}_2}\f$
@@ -69,7 +79,14 @@ class IGreensFunction
      *  \param[in]        p2 second point
      */
     double kernelD(const Eigen::Vector3d & direction, const Eigen::Vector3d & p1, const Eigen::Vector3d & p2) const {
-        return kernelD_impl(direction, p1, p2);
+      return kernelD_impl(direction, p1, p2);
+    }
+
+    KernelS exportKernelS() const {
+      return exportKernelS_impl();
+    }
+    KernelD exportKernelD() const {
+      return exportKernelD_impl();
     }
 
     /*! Whether the Green's function describes a uniform environment */
@@ -87,9 +104,9 @@ class IGreensFunction
     virtual Eigen::MatrixXd doubleLayer(const std::vector<Element> & e) const = 0;
 
     friend std::ostream & operator<<(std::ostream & os, IGreensFunction & gf) {
-        return gf.printObject(os);
+      return gf.printObject(os);
     }
-protected:
+  protected:
     /*! Returns value of the kernel of the \f$\mathcal{S}\f$ integral operator, i.e. the value of the
      *  Greens's function for the pair of points p1, p2: \f$ G(\mathbf{p}_1, \mathbf{p}_2)\f$
      *  \param[in] p1 first point
@@ -105,7 +122,9 @@ class IGreensFunction
      *  \param[in]        p2 second point
      */
     virtual double kernelD_impl(const Eigen::Vector3d & direction,
-                           const Eigen::Vector3d & p1, const Eigen::Vector3d & p2) const = 0;
+        const Eigen::Vector3d & p1, const Eigen::Vector3d & p2) const = 0;
+    virtual KernelS exportKernelS_impl() const = 0;
+    virtual KernelD exportKernelD_impl() const = 0;
     virtual std::ostream & printObject(std::ostream & os) = 0;
 };
 

src/green/IonicLiquid.hpp

@@ -36,7 +36,9 @@
 
 class Element;
 
+#include "DerivativeTypes.hpp"
 #include "DerivativeUtils.hpp"
+#include "bi_operators/IntegratorForward.hpp"
 #include "GreensFunction.hpp"
 #include "dielectric_profile/Yukawa.hpp"
 
@@ -49,8 +51,8 @@ class Element;
  *  \tparam IntegratorPolicy policy for the calculation of the matrix represenation of S and D
  */
 
-template <typename DerivativeTraits,
-          typename IntegratorPolicy>
+template <typename DerivativeTraits = AD_directional,
+          typename IntegratorPolicy = CollocationIntegrator>
 class IonicLiquid __final : public GreensFunction<DerivativeTraits, IntegratorPolicy, Yukawa,
                                      IonicLiquid<DerivativeTraits, IntegratorPolicy> >
 {
@@ -106,6 +108,12 @@ class IonicLiquid __final : public GreensFunction<DerivativeTraits, IntegratorPo
     {
         return this->profile_.epsilon * (this->derivativeProbe(direction, p1, p2));
     }
+    virtual KernelS exportKernelS_impl() const __override {
+      return pcm::bind(&IonicLiquid<DerivativeTraits, IntegratorPolicy>::kernelS, *this, pcm::_1, pcm::_2);
+    }
+    virtual KernelD exportKernelD_impl() const __override {
+      return pcm::bind(&IonicLiquid<DerivativeTraits, IntegratorPolicy>::kernelD, *this, pcm::_1, pcm::_2, pcm::_3);
+    }
     virtual std::ostream & printObject(std::ostream & os) __override
     {
         os << "Green's function type: ionic liquid" << std::endl;

src/green/SphericalDiffuse.hpp

@@ -39,6 +39,9 @@
 // Boost.Math includes
 #include <boost/math/special_functions/legendre.hpp>
 
+#include "DerivativeUtils.hpp"
+#include "bi_operators/IntegratorForward.hpp"
+#include "dielectric_profile/ProfileForward.hpp"
 #include "GreensFunction.hpp"
 #include "utils/MathUtils.hpp"
 
@@ -64,8 +67,8 @@
  *  at a pair of points, a translation of the sampling points is performed first.
  */
 
-template <typename IntegratorPolicy,
-          typename ProfilePolicy>
+template <typename IntegratorPolicy = CollocationIntegrator,
+          typename ProfilePolicy = OneLayerTanh>
 class SphericalDiffuse __final : public GreensFunction<Numerical, IntegratorPolicy, ProfilePolicy,
                                                SphericalDiffuse<IntegratorPolicy, ProfilePolicy> >
 {
@@ -248,6 +251,12 @@ class SphericalDiffuse __final : public GreensFunction<Numerical, IntegratorPoli
 
         return (eps_r2 * this->derivativeProbe(direction, p1, p2));
     }
+    virtual KernelS exportKernelS_impl() const __override {
+      return pcm::bind(&SphericalDiffuse<IntegratorPolicy, ProfilePolicy>::kernelS, *this, pcm::_1, pcm::_2);
+    }
+    virtual KernelD exportKernelD_impl() const __override {
+      return pcm::bind(&SphericalDiffuse<IntegratorPolicy, ProfilePolicy>::kernelD, *this, pcm::_1, pcm::_2, pcm::_3);
+    }
     virtual std::ostream & printObject(std::ostream & os) __override
     {
         Eigen::IOFormat CleanFmt(Eigen::StreamPrecision, 0, ", ", "\n", "(", ")");

src/green/SphericalSharp.hpp

@@ -34,7 +34,9 @@
 
 #include <Eigen/Core>
 
+#include "DerivativeTypes.hpp"
 #include "DerivativeUtils.hpp"
+#include "bi_operators/IntegratorForward.hpp"
 #include "GreensFunction.hpp"
 #include "utils/legendre.h"
 #include "utils/MathUtils.hpp"
@@ -49,8 +51,8 @@
  *  \tparam IntegratorPolicy policy for the calculation of the matrix represenation of S and D
  */
 
-template <typename DerivativeTraits,
-          typename IntegratorPolicy>
+template <typename DerivativeTraits = AD_directional,
+          typename IntegratorPolicy = CollocationIntegrator>
 class SphericalSharp __final : public GreensFunction<DerivativeTraits, IntegratorPolicy, Sharp,
                                               SphericalSharp<DerivativeTraits, IntegratorPolicy> >
 {
@@ -154,6 +156,12 @@ class SphericalSharp __final : public GreensFunction<DerivativeTraits, Integrato
     {
         return (this->profile_.epsilonSolvent * this->derivativeProbe(direction, p1, p2));
     }
+    virtual KernelS exportKernelS_impl() const __override {
+      return pcm::bind(&SphericalSharp<DerivativeTraits, IntegratorPolicy>::kernelS, *this, pcm::_1, pcm::_2);
+    }
+    virtual KernelD exportKernelD_impl() const __override {
+      return pcm::bind(&SphericalSharp<DerivativeTraits, IntegratorPolicy>::kernelD, *this, pcm::_1, pcm::_2, pcm::_3);
+    }
     DerivativeTraits imagePotential_impl(DerivativeTraits * sp, DerivativeTraits * pp) const
     {
         // Data from permittivity profile