save_surface_functions and load_surface_function are now defined in Interface.cpp

Author: Roberto Di Remigio

src/interface/Interface.cpp

@@ -175,6 +175,37 @@ extern "C" void compute_polarization_energy(double * energy)
     }
 }
 
+extern "C" void save_surface_functions()
+{
+    typedef SharedSurfaceFunctionMap::const_iterator surfMap_iter;
+    for ( surfMap_iter it = functions.begin(); it != functions.end(); ++it ) {
+	    std::string fname = it->second->name();
+	    unsigned int dim = static_cast<unsigned int>(it->second->nPoints());
+            const unsigned int shape[] = {dim};
+            cnpy::npy_save(fname, it->second->vector().data(), shape, 1, "w", true);
+    }
+}
+
+extern "C" void load_surface_function(const char * name)
+{
+    std::string functionName(name);
+    cnpy::NpyArray raw_surfFunc = cnpy::npy_load(functionName);
+    int dim = raw_surfFunc.shape[0];
+    if (dim != _cavity->size()) { 
+        throw std::runtime_error("Inconsistent dimension of loaded surface function!");
+    } else {
+	Eigen::VectorXd values = getFromRawBuffer<double>(dim, 1, raw_surfFunc.data); 
+        SharedSurfaceFunction func( new SurfaceFunction(functionName, dim, values) );
+	// Append to global map
+        SharedSurfaceFunctionMap::iterator iter = functions.lower_bound(functionName);
+        if ( iter == functions.end()  ||  iter->first != functionName ) {                                   
+            if ( iter != functions.begin() ) --iter;
+            SharedSurfaceFunctionPair insertion = SharedSurfaceFunctionMap::value_type(functionName, func);
+            iter = functions.insert(iter, insertion);
+        }
+   }
+}
+
 extern "C" void dot_surface_functions(double * result, const char * potString,
                                       const char * chgString)
 {

src/interface/Interface.hpp

@@ -92,14 +92,14 @@ extern "C" void compute_polarization_energy(double * energy);
 extern "C" void save_surface_functions();
 
 #define load_surface_functions \
-	FortranCInterface_GLOBAL_(load_surface_functions, load_SURFACE_FUNCTIONS)
-/*! \fn extern "C" void load_surface_functions(const char * name)
+	FortranCInterface_GLOBAL_(load_surface_function, load_SURFACE_FUNCTION)
+/*! \fn extern "C" void load_surface_function(const char * name)
  *  \brief Loads the surface function from a .npy file
  *  \param[in] name the name of the surface function to be loaded from file
  *
  *  The name has to be consistent with that of the .npy file saved using save_surface_functions()
  */
-extern "C" void load_surface_functions(const char * name);
+extern "C" void load_surface_function(const char * name);
 
 #define dot_surface_functions \
 	FortranCInterface_GLOBAL_(dot_surface_functions, DOT_SURFACE_FUNCTIONS)

src/utils/SurfaceFunction.hpp

@@ -91,13 +91,13 @@ class SurfaceFunction
     /// Division-assignment operator. Defined only for the uniform scaling case.
     SurfaceFunction & operator/=(double scaling);
 
-    std::string & name() { return name_; }
-    int nPoints() { return nPoints_; }
+    const std::string & name() const { return name_; }
+    int nPoints() const { return nPoints_; }
     void value(int index, double value) { values_(index) = value; }
-    double value(int index) { return values_(index); }
+    double value(int index) const { return values_(index); }
     Eigen::VectorXd & vector() { return values_; }
     void allocate(int np) { values_.resize(np); }
-    bool allocated() { return allocated_; }
+    bool allocated() const { return allocated_; }
     void clear();
 
     void setValues(double * v);