Accepting host_input when host is Fortran seems finally working

Author: Roberto Di Remigio

api/pcmsolver.F90

@@ -25,24 +25,24 @@ module pcmsolver
     public pcmsolver_write_timings
 
     type, public, bind(C) :: PCMInput
-        character(kind=c_char, len=1) :: cavity_type(8)
-        integer(c_int)                :: patch_level
-        real(c_double)                :: coarsity
-        real(c_double)                :: area
-        real(c_double)                :: min_distance
-        integer(c_int)                :: der_order
-        logical(c_bool)               :: scaling
-        character(kind=c_char, len=1) :: radii_set(8)
-        character(kind=c_char, len=1) :: restart_name(20)
-        real(c_double)                :: min_radius
-        character(kind=c_char, len=1) :: solver_type(7)
-        character(kind=c_char, len=1) :: solvent(16)
-        character(kind=c_char, len=1) :: equation_type(11)
-        real(c_double)                :: correction
-        real(c_double)                :: probe_radius
-        character(kind=c_char, len=1) :: inside_type(7)
-        real(c_double)                :: outside_epsilon
-        character(kind=c_char, len=1) :: outside_type(22)
+        character(kind=c_char, len=1) :: cavity_type(8) = 'abcdefg'//c_null_char
+        integer(c_int)                :: patch_level = 0
+        real(c_double)                :: coarsity = 0.0
+        real(c_double)                :: area = 0.0
+        character(kind=c_char, len=1) :: radii_set(8) = 'abcdefg'//c_null_char
+        real(c_double)                :: min_distance = 0.0
+        integer(c_int)                :: der_order = 0
+        logical(c_bool)               :: scaling = .false.
+        character(kind=c_char, len=1) :: restart_name(20) = 'abcdefghijklmnopqrs'//c_null_char
+        real(c_double)                :: min_radius = 0.0
+        character(kind=c_char, len=1) :: solver_type(7) = 'abcdef'//c_null_char
+        real(c_double)                :: correction = 0.0
+        character(kind=c_char, len=1) :: solvent(16) = 'abcdefghijklmno'//c_null_char
+        real(c_double)                :: probe_radius = 0.0
+        character(kind=c_char, len=1) :: equation_type(11) = 'abcdefghij'//c_null_char
+        character(kind=c_char, len=1) :: inside_type(7) = 'abcde'//c_null_char
+        real(c_double)                :: outside_epsilon = 0.0
+        character(kind=c_char, len=1) :: outside_type(22) = 'abcdefghijklmnopqrstu'//c_null_char
     end type PCMInput
 
     public PCMSOLVER_READER_OWN

cmake/custom/autogenerated.cmake

@@ -4,3 +4,4 @@ configure_file(${PROJECT_SOURCE_DIR}/Config.hpp.in ${PROJECT_BINARY_DIR}/include
 get_property(PCMSOLVER_EXECUTABLE GLOBAL PROPERTY PCMSolver_EXECUTABLE)
 # Configure the input parsing script
 configure_file(${PROJECT_SOURCE_DIR}/tools/pcmsolver.py.in ${PROJECT_BINARY_DIR}/bin/pcmsolver.py @ONLY)
+install(FILES ${PROJECT_BINARY_DIR}/bin/pcmsolver.py DESTINATION bin)

cmake/custom/compilers/GNU.Fortran.cmake

@@ -1,7 +1,7 @@
 # Overrides contents of all variables previously set by CMake
 if(NOT DEFINED ENV{FCFLAGS})
     if(CMAKE_Fortran_COMPILER_ID MATCHES GNU)
-        set(CMAKE_Fortran_FLAGS "-DVAR_GFORTRAN -DGFORTRAN=445 -fimplicit-none -fPIC -fautomatic -fmax-errors=1")
+        set(CMAKE_Fortran_FLAGS "-fimplicit-none -fPIC -fautomatic -fmax-errors=1")
         set(CMAKE_Fortran_FLAGS_DEBUG   "-O0 -g -fbacktrace -Wall -Wextra ${Fcheck_all}")
         set(CMAKE_Fortran_FLAGS_RELEASE "-O3 -funroll-all-loops -ftree-vectorize")
     endif()

doc/gfx/interface.png

@@ -26,25 +26,13 @@
 #ifndef PCMINPUT_HPP
 #define PCMINPUT_HPP
 
-#include <algorithm>
 #include <iostream>
 #include <string>
 
 #include "Config.hpp"
 
-#include <boost/algorithm/string.hpp>
-
-inline bool invalidChar(char c);
-
 struct PCMInput;
 inline void print(const PCMInput &);
-inline void init(PCMInput &);
-inline void trim(PCMInput &);
-
-bool invalidChar(char c)
-{
-    return !std::isprint( static_cast<unsigned char>( c ) );
-}
 
 /*! @struct PCMInput
  *  @brief Data structure for host-API input communication.
@@ -59,28 +47,28 @@ struct PCMInput
 	double coarsity;
 	/// Average tesserae area.
 	double area;
+	/// The built-in radii set to be used.
+	char radii_set[8];
 	/// Minimal distance between sampling points.
 	double min_distance;
 	/// Derivative order for the switching function.
 	int der_order;
 	/// Whether to scale or not the atomic radii.
 	bool scaling;
-	/// The built-in radii set to be used.
-	char radii_set[8];
 	/// Name of the .npz file for GePol cavity restart.
 	char restart_name[20];
 	/// Minimal radius for the added spheres.
 	double min_radius;
 	/// Type of solver requested.
 	char solver_type[7];
-	/// Name of the solvent.
-	char solvent[16];
-	/// Type of the integral equation to be used.
-	char equation_type[11];
 	/// Correction in the CPCM apparent surface charge scaling factor.
 	double correction;
+	/// Name of the solvent.
+	char solvent[16];
 	/// Radius of the spherical probe mimicking the solvent.
 	double probe_radius;
+	/// Type of the integral equation to be used.
+	char equation_type[11];
 	/// Type of Green's function requested inside the cavity.
 	char inside_type[7];
 	/// Value of the static permittivity outside the cavity.
@@ -110,78 +98,5 @@ void print(const PCMInput & inp)
     std::cout << "outside type " << std::string(inp.outside_type) << std::endl;
     std::cout << "epsilon outside " << inp.outside_epsilon << std::endl;
 }
-void init(PCMInput & inp)
-{
-    inp.patch_level = 0;
-    std::fill((inp.cavity_type), (inp.cavity_type) + 8, 0);
-    inp.coarsity = 0.0;
-    inp.area = 0.0;
-    inp.min_distance = 0.0;
-    inp.der_order = 0;
-    inp.scaling = false;
-    std::fill((inp.radii_set), (inp.radii_set) + 8, 0);
-    std::fill((inp.restart_name), (inp.restart_name) + 20, 0);
-    inp.min_radius = 0.0;
-    std::fill((inp.solver_type), (inp.solver_type) + 7, 0);
-    inp.correction = 0.0;
-    std::fill((inp.solvent), (inp.solvent) + 16, 0);
-    inp.probe_radius = 0.0;
-    std::fill((inp.equation_type), (inp.equation_type) + 11, 0);
-    std::fill((inp.inside_type), (inp.inside_type) + 7, 0);
-    inp.outside_epsilon = 0.0;
-    std::fill((inp.outside_type), (inp.outside_type) + 22, 0);
-}
-void trim(PCMInput & inp)
-{
-    std::string s1(inp.cavity_type);
-    s1.erase(std::remove_if(s1.begin(), s1.end(), invalidChar), s1.end());
-    boost::algorithm::trim(s1);
-    std::fill((inp.cavity_type), (inp.cavity_type) + 8, 0);
-    strncpy(inp.cavity_type, s1.c_str(), s1.length());
-
-    /*
-    std::string s2(inp.restart_name);
-    s2.erase(std::remove_if(s2.begin(), s2.end(), invalidChar), s2.end());
-    boost::algorithm::trim(s2);
-    std::fill((inp.restart_name), (inp.restart_name) + 20, 0);
-    strncpy(inp.cavity_type, s2.c_str(), s2.length());
-
-    std::string s3(inp.radii_set);
-    s3.erase(std::remove_if(s3.begin(), s3.end(), invalidChar), s3.end());
-    boost::algorithm::trim(s3);
-    std::fill((inp.radii_set), (inp.radii_set) + 8, 0);
-    strncpy(inp.cavity_type, s3.c_str(), s3.length());
-
-    std::string s4(inp.solver_type);
-    s4.erase(std::remove_if(s4.begin(), s4.end(), invalidChar), s4.end());
-    boost::algorithm::trim(s4);
-    std::fill((inp.solver_type), (inp.solver_type) + 7, 0);
-    strncpy(inp.solver_type, s4.c_str(), s4.length());
-
-    std::string s5(inp.solvent);
-    s5.erase(std::remove_if(s5.begin(), s5.end(), invalidChar), s5.end());
-    boost::algorithm::trim(s5);
-    std::fill((inp.solvent), (inp.solvent) + 16, 0);
-    strncpy(inp.solvent, s5.c_str(), s5.length());
-
-    std::string s6(inp.equation_type);
-    s6.erase(std::remove_if(s6.begin(), s6.end(), invalidChar), s6.end());
-    boost::algorithm::trim(s6);
-    std::fill((inp.equation_type), (inp.equation_type) + 11, 0);
-    strncpy(inp.equation_type, s6.c_str(), s6.length());
-
-    std::string s7(inp.inside_type);
-    s7.erase(std::remove_if(s7.begin(), s7.end(), invalidChar), s7.end());
-    boost::algorithm::trim(s7);
-    std::fill((inp.inside_type), (inp.inside_type) + 7, 0);
-    strncpy(inp.inside_type, s7.c_str(), s7.length());
-
-    std::string s8(inp.outside_type);
-    s8.erase(std::remove_if(s8.begin(), s8.end(), invalidChar), s8.end());
-    boost::algorithm::trim(s8);
-    std::fill((inp.outside_type), (inp.outside_type) + 22, 0);
-    strncpy(inp.outside_type, s8.c_str(), s8.length());
-    */
-}
 
 #endif // PCMINPUT_HPP

doc/gfx/utils.png

@@ -25,6 +25,15 @@
 
 #include "FortranCUtils.hpp"
 
+#include "Config.hpp"
+
+#include <cctype>
+#include <cstring>
+
+#ifndef _fcdtocp
+#define _fcdtocp(desc) (desc)
+#endif
+
 void pcmsolver_c2f_string(char * src, char * dest, int * len)
 {
     int sofar;
@@ -33,3 +42,20 @@ void pcmsolver_c2f_string(char * src, char * dest, int * len)
     while (sofar++ < *len)
         *dest++ = ' ';
 }
+
+void pcmsolver_f2c_string(char * src, char * dest, int * len)
+{
+    char * str; /* Pointer to FORTRAN string */
+    int i;      /* Local index variable */
+
+    /* Search for the end of the string */
+    str = _fcdtocp(src);
+    for(i = (int)*len - 1; i >= 0 && !std::isgraph((int)str[i]); i--)
+        /*EMPTY*/;
+
+    /* Copy text from FORTRAN to C string */
+    std::memcpy(dest, str, (size_t)(i + 1));
+
+    /* Terminate C string */
+    dest[i + 1] = '\0';
+}

src/interface/PCMInput.hpp

@@ -32,17 +32,28 @@
 extern "C" {
 #endif
 
-/*! \brief Convert C string to Fortran string
+/*! \brief Convert a C string to a Fortran string
  *  \param[in] src the string to convert
- *  \param[out] src the string to convert
+ *  \param[out] dest the converted string
  *  \param[in]      len length of Fortran string
  *  Change a C string (NULL terminated) into a Fortran string.
  *  Basically, all that is done is that the NULL is ripped out
  *  and the string is padded with spaces
  */
 #define pcmsolver_c2f_string \
     FortranCInterface_GLOBAL_(pcmsolver_c2f_string, PCMSOLVER_C2F_STRING)
-    void pcmsolver_c2f_string(char * src, char * dest, int * len);
+void pcmsolver_c2f_string(char * src, char * dest, int * len);
+
+/*! \brief Convert a Fortran string to a C string
+ *  \param[in] src Fortran string
+ *  \param[out] dest C string
+ *  \param[in] len length of Fortran string
+ *  Chop off trailing blanks off of a Fortran string and
+ *  move it into C string.
+ */
+#define pcmsolver_f2c_string \
+    FortranCInterface_GLOBAL_(pcmsolver_f2c_string, PCMSOLVER_F2C_STRING)
+void pcmsolver_f2c_string(char * src, char * dest, int * len);
 
 #ifdef __cplusplus
 }

src/utils/FortranCUtils.cpp

@@ -46,6 +46,7 @@
 #include "Sphere.hpp"
 
 using boost::algorithm::to_upper_copy;
+using boost::algorithm::trim;
 
 Input::Input(const std::string & filename)
 {
@@ -172,38 +173,50 @@ void Input::reader(const std::string & filename)
     providedBy_ = std::string("API-side");
 }
 
+std::string trim(const char * src)
+{
+    std::string tmp(src);
+    trim(tmp);
+    return tmp;
+}
+
+std::string trim_and_upper(const char * src)
+{
+    return to_upper_copy(trim(src));
+}
+
 void Input::reader(const PCMInput & host_input)
 {
     CODATAyear_ = 2010;
 
-    type_ = to_upper_copy(std::string(host_input.cavity_type));
+    type_ = trim_and_upper(host_input.cavity_type);
     area_ = host_input.area * angstrom2ToBohr2(CODATAyear_);
     patchLevel_ = host_input.patch_level;
     coarsity_ = host_input.coarsity * angstromToBohr(CODATAyear_);
     minDistance_ = host_input.min_distance * angstromToBohr(CODATAyear_);
     derOrder_ = host_input.der_order;
     if (type_ == "RESTART") {
-        cavFilename_ = std::string(host_input.restart_name); // No case conversion here!
+        cavFilename_ = trim(host_input.restart_name); // No case conversion here!
     }
 
     scaling_ = host_input.scaling;
-    radiiSet_ = host_input.radii_set;
+    radiiSet_ = trim_and_upper(host_input.radii_set);
     minimalRadius_ = host_input.min_radius * angstromToBohr(CODATAyear_);
     mode_ = std::string("IMPLICIT");
 
-    std::string name = to_upper_copy(std::string(host_input.solvent));
+    std::string name = trim_and_upper(host_input.solvent);
     if (name.empty()) {
         hasSolvent_ = false;
         // Get the probe radius
         probeRadius_ = host_input.probe_radius * angstromToBohr(CODATAyear_);
         // Get the contents of the Green<inside> section...
         // ...and initialize the data members
-        greenInsideType_ = to_upper_copy(std::string(host_input.inside_type));
+        greenInsideType_ = trim_and_upper(host_input.inside_type);
         derivativeInsideType_ = derivativeTraits("DERIVATIVE");
         epsilonInside_ = 1.0;
         // Get the contents of the Green<outside> section...
         // ...and initialize the data members
-        greenOutsideType_ = to_upper_copy(std::string(host_input.outside_type));
+        greenOutsideType_ = trim_and_upper(host_input.outside_type);
         derivativeOutsideType_ = derivativeTraits("DERIVATIVE");
         epsilonStaticOutside_ = host_input.outside_epsilon;
         epsilonDynamicOutside_ = host_input.outside_epsilon;
@@ -226,8 +239,8 @@ void Input::reader(const PCMInput & host_input)
     }
     integratorType_ = integratorPolicy("COLLOCATION"); // Currently hardcoded!!!
 
-    solverType_ = to_upper_copy(std::string(host_input.solver_type));
-    std::string inteq = to_upper_copy(std::string(host_input.equation_type));
+    solverType_ = trim_and_upper(host_input.solver_type);
+    std::string inteq = trim_and_upper(host_input.equation_type);
     equationType_ = integralEquation(inteq);
     correction_ = host_input.correction;
     hermitivitize_ = true;

src/utils/FortranCUtils.hpp

@@ -136,7 +136,7 @@ class Input
      *  The "Atoms" and "Explicit" methods are only available using the explicit parsing
      *  by our Python script of a separate input file.
      */
-    void reader(const PCMInput & host_input); 
+    void reader(const PCMInput & host_input);
     /*! Perform semantic input parsing aka sanity check */
     void semanticCheck();
 
@@ -264,4 +264,8 @@ int profilePolicy(const std::string & name);
 /*! A useful map to convert the EquationType string to an integer which will be passed to the Solver CTOR. */
 int integralEquation(const std::string & name);
 
+std::string trim(const char * src);
+
+std::string trim_and_upper(const char * src);
+
 #endif // INPUT_HPP