Moved GBSA reference code into the reference platform directory

platforms/reference/src/Gbsa/C-source/CommonSimTk.h

+
+/* Portions copyright (c) 2006 Stanford University and Simbios.
+ * Contributors: Pande Group
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __CommonSimTk_H__
+#define __CommonSimTk_H__
+
+// include file containing entries commonly used
+
+// STL includes
+
+#include <vector>
+#include <map>
+#include <set>
+#include <string>
+
+// generic c includes
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <math.h>
+#include <assert.h>
+
+// ---------------------------------------------------------------------------------------
+
+typedef std::vector<int> IntVector;
+typedef IntVector::iterator IntVectorI;
+typedef IntVector::const_iterator IntVectorCI;
+typedef IntVector::reverse_iterator IntVectorRI;
+typedef IntVector::const_reverse_iterator IntVectorCRI;
+
+typedef std::map<int, int> IntIntMap;
+typedef IntIntMap::iterator IntIntMapI;
+typedef IntIntMap::const_iterator IntIntMapCI;
+
+typedef std::set<int> IntSet;
+typedef IntSet::iterator IntSetI;
+typedef IntSet::const_iterator IntSetCI;
+
+typedef std::multiset<int> IntMultiSet;
+typedef IntMultiSet::iterator IntMultiSetI;
+typedef IntMultiSet::const_iterator IntMultiSetCI;
+
+typedef std::vector<std::string> StringVector;
+typedef StringVector::iterator StringVectorI;
+typedef StringVector::const_iterator StringVectorCI;
+
+typedef std::map<std::string, std::string> StringStringMap;
+typedef StringStringMap::iterator StringStringMapI;
+typedef StringStringMap::const_iterator StringStringMapCI;
+
+// ---------------------------------------------------------------------------------------
+
+// StringComparisonForMap: used to compare strings in STL maps w/ strings as keys
+
+class StringComparisonForMapPtr : public std::binary_function< std::string*, std::string*, bool > {
+
+   public:
+
+      bool operator()( const std::string* str1, const std::string* str2 ) const {
+         return strcmp( str1->c_str(), str2->c_str() ) < 0;
+      }
+};
+
+class StringComparisonForMap : public std::binary_function< const std::string&, const std::string&, bool > {
+
+   public:
+
+      bool operator()( const std::string& str1, const std::string& str2 ) const {
+         return strcmp( str1.c_str(), str2.c_str() ) < 0;
+      }
+};
+
+// ---------------------------------------------------------------------------------------
+
+// Used to compare integers for sorting, ...
+
+int numericCompareI( const void* point1, const void* point2 );
+
+// ---------------------------------------------------------------------------------------
+
+// string-string map and iterator definitions
+
+typedef std::map<std::string, std::string, StringComparisonForMap> StringMap;
+typedef StringMap::iterator StringMapI;
+typedef StringMap::const_iterator StringMapCI;
+
+// string set and iterator definitions
+
+typedef std::set<std::string, StringComparisonForMap> StringSet;
+typedef StringSet::iterator StringSetI;
+typedef StringSet::const_iterator StringSetCI;
+
+// ---------------------------------------------------------------------------------------
+
+#endif // __CommonSimTk_H__

platforms/reference/src/Gbsa/C-source/CpuGbsa.h

+
+/* Portions copyright (c) 2006 Stanford University and Simbios.
+ * Contributors: Pande Group
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __CpuGbsa_H__
+#define __CpuGbsa_H__
+
+#include "GbsaParameters.h"
+
+// ---------------------------------------------------------------------------------------
+
+class CpuGbsa {
+
+   private:
+
+      // used for direct calls from Gromacs
+
+      static CpuGbsa* _cpuGbsa;
+
+      // GBSA parameters
+
+      GbsaParameters* _gbsaParameters;
+
+      // flag to signal whether ACE approximation
+      // is to be included
+
+      bool _includeAceApproximation;
+
+      // work arrays and their accessors
+
+      float* _gbsaBornForce;
+      float* _gbsaBornRadiiTemp;
+
+      float* getGbsaBornForce( void );
+      float* getGbsaBornRadiiTemp( void );
+
+      // initialize data members (more than
+      // one constructor, so centralize intialization here)
+
+      void initializeDataMembers( void );
+
+      // convert units for energy/force
+
+      float _forceConversionFactor;
+      float _energyConversionFactor;
+
+      // Ed, 2007-04-27: Store the energy internally
+      float _gbsaEnergy; 
+
+   public:
+
+       // constructors/destructor
+
+       CpuGbsa( int numberOfAtoms, const t_topology* top, FILE* log );
+       CpuGbsa( GbsaParameters* gbsaParameters );
+
+       ~CpuGbsa( );
+
+      // override of new/delete
+
+      static void* operator new( size_t size ); 
+      static void  operator delete( void *p );
+
+      static void* operator new[]( size_t size ); 
+      static void  operator delete[]( void *p );
+
+      // accessor for the energy
+
+		float getEnergy( void ) const { return _gbsaEnergy; }
+
+      // accessor for static member _cpuGbsa
+
+      static int setCpuGbsa( CpuGbsa* cpuGbsa ){ _cpuGbsa = cpuGbsa; return 0; };
+      static CpuGbsa* getCpuGbsa( void ){ return _cpuGbsa; };
+      static int deleteCpuGbsa( void );
+
+      // accessors for Gbsa parameters
+
+      GbsaParameters* getGbsaParameters( void ) const { return _gbsaParameters; };
+      int setGbsaParameters( GbsaParameters* gbsaParameters ){ _gbsaParameters = gbsaParameters; return 0; };
+ 
+      // accessors ACE approximation
+
+      bool includeAceApproximation( void ) const { return _includeAceApproximation; };
+      int setIncludeAceApproximation( bool includeAceApproximation ){ _includeAceApproximation = includeAceApproximation; return 0; };
+
+      // energy/force conversion factors
+
+      float getForceConversionFactor(  void  ) const { return _forceConversionFactor;  };  
+      float getEnergyConversionFactor( void  ) const { return _energyConversionFactor; };  
+
+      int setForceConversionFactor(  float forceConversionFactor  ){ _forceConversionFactor  = forceConversionFactor;  return 0; };  
+      int setEnergyConversionFactor( float energyConversionFactor ){ _energyConversionFactor = energyConversionFactor; return 0; };  
+
+      /**---------------------------------------------------------------------------------------
+      
+         Get Born energy and forces based on J. Phys. Chem. A V101 No 16, p. 3005 (Simbios)
+      
+         @param atomCoordinates   atomic coordinates
+         @param partialCharges    partial charges
+         @param forces            forces (output); if not set on input, then memory is allocated
+         @param log               if set, then print error messages to log file
+      
+         @return force array
+      
+         --------------------------------------------------------------------------------------- */
+      
+      static float** computeGbsaForces( const rvec *atomCoordinates, const float* partialCharges,
+                                        float** forces, FILE* log );
+      
+      /**---------------------------------------------------------------------------------------
+      
+         Get Born radii based on J. Phys. Chem. A V101 No 16, p. 3005 (Simbios)
+      
+         @param atomCoordinates   atomic coordinates
+         @param bornRadii         output array of Born radii
+      
+         @return array of Born radii
+      
+         --------------------------------------------------------------------------------------- */
+      
+      int computeBornRadii( const rvec *atomCoordinates, float* bornRadii );
+      
+      /**---------------------------------------------------------------------------------------
+      
+         Get exclusions for specific atom (Simbios)
+      
+         @param numberOfAtoms         number of atoms
+         @param gbsaBondsArray        array of bonds
+         @param atomI                 atom index of atom for which exclusions are to be set
+         @param exclusionWorkArray    exclusionWorkArray[j] = 1, if atom j is to be excluded
+                                      value may be null on input in which space is allocated
+         @param previousIndex         previousIndex -- if < 0, then iniitialize all entries to 0
+         @param log                   if set, then print error messages to log file
+      
+         @return 0
+      
+         --------------------------------------------------------------------------------------- */
+      
+      int getExclusionsForAtom( int numberOfAtoms, gbsaBonds** gbsaBondsArray,
+                                int atomI, int* exclusionWorkArray, int previousIndex,
+                                FILE* log ) const;
+
+      /**---------------------------------------------------------------------------------------
+      
+         Set exclusions for specific atom (Simbios)
+      
+         @param gbsaBonds           gbsa bond
+         @param setValue            set value
+         @param exclusionWorkArray  exclusionWorkArray[j] = 1, if atom j is to be excluded
+                                    value may be null on input in which space is allocated
+         @param log                 if set, then print error messages to log file
+      
+         @return array of Born radii
+      
+         --------------------------------------------------------------------------------------- */
+      
+      int setExclusionValue( gbsaBonds* gbsaBonds, int setValue, int* exclusionWorkArray, FILE* log ) const;
+         
+      /**---------------------------------------------------------------------------------------
+      
+         Get Born energy and forces based on J. Phys. Chem. A V101 No 16, p. 3005 (Simbios)
+      
+         @param bornRadii         Born radii
+         @param atomCoordinates   atomic coordinates
+         @param partialCharges    partial charges
+         @param forces            forces
+      
+         @return force array
+      
+         --------------------------------------------------------------------------------------- */
+      
+      float** computeBornEnergyForces( float* bornRadii, const rvec *atomCoordinates,
+                                       const float* partialCharges, float** forces );
+      
+      /**---------------------------------------------------------------------------------------
+      
+         Get Born energy and forces based on J. Phys. Chem. A V101 No 16, p. 3005 (Simbios)
+      
+         @param top               GMX t_topology struct
+         @param bornRadii         Born radii
+         @param atomCoordinates   atomic coordinates
+         @param partialCharges    atom partial charges
+         @param energy            energy
+         @param debugOn           enable debug
+         @param debugAtomI        debug flag for atomI (outer loop atom)
+         @param debugAtomJ        debug flag for atomJ (inner loop atom)
+         @param debugReport       flag signalling what quantities are to be saved for comparisons
+         @param saveLoopForces    flag signalling whether intermediate results for each loop
+                                  are to be retained
+         @param printOn           print flag 
+         @param unsetDebugValue   ?
+         @param numberOfDebugStreams 
+                                  number of debug streams
+         @param debugStreams      array of debug streams
+         @param forces            force array (may be null)
+         @param log               if set, then print error messages to log file
+      
+         @return 0 always; fixed value for G_pol in array 'gPolFixed'
+      
+         --------------------------------------------------------------------------------------- */
+      
+      float** computeBornEnergyForcesDebug( const t_topology* top, 
+                                            float* bornRadii, const rvec *atomCoordinates,
+                                            const float* partialCharges, float* energy,
+                                            bool debugOn, int debugAtomI, int debugAtomJ,
+                                            int debugReport, bool* saveLoopForces,
+                                            bool printOn, float unsetDebugValue, int numberOfDebugStreams,
+                                            float** debugStreams, float** forces, FILE* log );
+ 
+      /**---------------------------------------------------------------------------------------
+      
+         Write Born energy and forces (Simbios)
+      
+         @param top               GMX t_topology struct
+         @param atomCoordinates   atomic coordinates
+         @param partialCharges    partial atom charges
+         @param forces            force array
+         @param gbsaResultsFileName  output file name
+         @param log               if set, then print error messages to log file
+      
+         @return 0 always
+      
+         --------------------------------------------------------------------------------------- */
+      
+      int writeBornEnergyForces( const t_topology* top, const rvec *atomCoordinates,
+                                 const float* partialCharges, float** forces,
+                                 const char* gbsaResultsFileName, FILE* log ) const;
+
+      /**---------------------------------------------------------------------------------------
+      
+         Print state to log file (Simbios)
+      
+         title             title (optional)
+         log               print state to log file
+      
+         @return 0 always;
+      
+         --------------------------------------------------------------------------------------- */
+      
+      int logState( const char* title, FILE* log ) const;
+
+      /**---------------------------------------------------------------------------------------
+      
+         Write Tinker xyz file (Simbios)
+      
+         @param numberOfAtoms      number of atoms
+         @param atomCoordinates    atom coordinates
+         @param header             header
+         @param xyzFileName        output file name
+         @param gbsaBondsArray     bond array -- used to print 1-2 bonds
+         @param top                GMX t_topology struct
+         @param log                if set, then print error messages to log file
+      
+         @return 0 unless error detected
+      
+         Currently no attempt is made to get the atom name/type to accurately 
+         reflect the Tinker names/types. Rather method is used to output atoms
+         in Gromacs order and then reorder those in a corresponding xyz file
+         w/ the correct atom names/types so that they match the Gromacs order
+         This makes it easier to compare results between Gromacs and Tinker
+      
+         --------------------------------------------------------------------------------------- */
+      
+      static int writeXyzFile( int numberOfAtoms, const rvec* atomCoordinates, 
+                               const char* header, const char* xyzFileName,
+                               gbsaBonds** gbsaBondsArray, const t_topology* top, FILE* log );
+      
+};
+
+// ---------------------------------------------------------------------------------------
+
+#endif // __CpuGbsa_H__

platforms/reference/src/Gbsa/C-source/RealTypeSimTk.h

+
+/* Portions copyright (c) 2006 Stanford University and Simbios.
+ * Contributors: Pande Group
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+#ifndef __RealSimTk_H_
+#define __RealSimTk_H__
+
+#ifndef RealType
+#define RealType 2
+#endif 
+
+#if RealType == 1 
+#define Real float
+#define SQRT sqrtf
+#define POW  powf
+#define SIN  sinf
+#define COS  cosf
+#define TAN  tanf
+
+// LOG is used in Vishal's gpu code; modifying LOG -> LN 
+#define LN   logf
+
+#define EXP  expf
+#define FABS fabsf
+#define ACOS acosf
+#define ASIN asinf
+#define ATAN atanf
+#else
+#define Real double
+#define SQRT sqrt
+#define POW  pow
+#define SIN  sin
+#define COS  cos
+#define TAN  tan
+
+// LOG is used in Vishal's gpu code; modifying LOG -> LN 
+#define LN   log
+
+#define EXP  exp
+#define FABS fabs
+#define ACOS acos
+#define ASIN asin
+#define ATAN atan
+#endif
+
+#define DOT3(u,v) ((u[0])*(v[0]) + (u[1])*(v[1]) + (u[2])*(v[2]))
+
+#define MATRIXDOT3(u,v) u[0]*v[0] + u[1]*v[1] + u[2]*v[2] + \
+                        u[3]*v[3] + u[4]*v[4] + u[5]*v[5] + \
+                        u[6]*v[6] + u[7]*v[7] + u[8]*v[8]
+
+#define PI              3.141592653589f
+#define TWO_SIX         1.122462048309372981f
+#define RADIAN         57.29577951308f
+#define LOG_TEN         2.302585092994045684f
+#define SQRT_TWO        1.41421356237309504f
+#define RADIAN_INVERSE  0.01745329252f
+
+#endif // __RealSimTk_H__

platforms/reference/src/Gbsa/C-source/gbsaCpu.cpp

+
+/* Portions copyright (c) 2006 Stanford University and Simbios.
+ * Contributors: Pande Group
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "CpuGbsa.h"
+
+// 'gmxGbsa.h' has declarations for cpuSetGbsaParameters() and
+// and cpuCalculateGbsaForces()
+
+#include "gmxGbsa.h"
+
+/**---------------------------------------------------------------------------------------
+
+	Example calling sequence:
+
+		float** forces = NULL;
+      float energy;
+      cpuSetGbsaParameters( mdatoms->nr, top, stdlog );
+
+      // if 'forces' array is initially null, then memory will
+      // be allocated by cpuCalculateGbsaForces()
+
+      // format for 'forces' array:
+		//		forces[3][numberAtoms]
+
+      forces = cpuCalculateGbsaForces( x, mdatoms->chargeA, &energy,
+                                      forces, stdlog );
+
+   --------------------------------------------------------------------------------------- */
+
+/**---------------------------------------------------------------------------------------
+
+	Setup for Gbsa calculations
+
+   @param numberOfAtoms            number of atoms
+   @param top                      Gromacs t_topology (as in md.c)
+   @param log                      log reference (stdlog in md.c)
+   @param includeAceApproximation  if true, then include nonpolar 
+                                   ACE term in calculataions
+   @param innerDielectric          nonsolvent dielectric
+   @param solventDielectric        solvent dielectric
+
+   function creates a CpuGbsa instance; the created object is a static member of the
+   class CpuGbsa; when the force routine (a static method) is called, the object is
+   used to compute the forces and energy 
+
+  @return 0
+
+   --------------------------------------------------------------------------------------- */
+
+extern "C" int 
+cpuSetGbsaParameters( int numberOfAtoms, const t_topology* top, FILE* log,
+                      bool includeAceApproximation,
+                      float innerDielectric, float solventDielectric ){
+
+   // ---------------------------------------------------------------------------------------
+
+   static bool printGbsaParameters           = false;
+   static const char* methodName             = "\ncpuSetGbsaParameters: ";
+
+   // static bool debug                         = true;
+   static bool debug                         = false;
+
+   // ---------------------------------------------------------------------------------------
+   
+   // toggle whether logging enabled
+
+   FILE* cpuGbsaLog               = debug ? log : NULL;
+   CpuGbsa* cpuGbsa               = new CpuGbsa( numberOfAtoms, top, cpuGbsaLog );
+
+   // include/not include ACE approximation (nonpolar solvation)
+
+   cpuGbsa->setIncludeAceApproximation( includeAceApproximation );
+   // cpuGbsa->setIncludeAceApproximation( false );
+   // cpuGbsa->setIncludeAceApproximation( true );
+
+   // default values are      1.0/1.0      -> gives values in 10.0*kcal/A (force) and 100*kcal/A (energy)
+   //      if values are 0.41868/0.41868   -> gives values in Gromacs units kJ/nm
+
+   if( !debug ){
+      cpuGbsa->setForceConversionFactor(  0.41868f );
+      cpuGbsa->setEnergyConversionFactor( 0.41868f );
+   }
+
+   // dielectrics
+
+   cpuGbsa->getGbsaParameters()->setSolventDielectric( solventDielectric );
+   cpuGbsa->getGbsaParameters()->setInnerDielectric( innerDielectric );
+
+   // set static member for subsequent calls to calculate forces/energy 
+
+   CpuGbsa::setCpuGbsa( cpuGbsa );
+
+   // ---------------------------------------------------------------------------------------
+
+   if( log != NULL ){
+      cpuGbsa->logState( methodName, log );
+      (void) fprintf( log, "%s done", methodName );
+      (void) fflush( log );
+   }
+
+   // ---------------------------------------------------------------------------------------
+
+   return 0;
+}
+
+/**---------------------------------------------------------------------------------------
+
+   Calculate Gbsa forces and energy \n
+
+   @param atomCoordinates   Gromacs atom coordinates ('x' in md.c)
+   @param partialCharges    Gromacs charges ('mdatoms->chargeA' in md.c)
+   @param energy            output energy
+   @param forces            output forces (format currently forces[3][numberOfAtoms])
+                            if 'forces' reference is NULL upon input, then \n
+                            memory is allocated for array; responsibilty of callee  \n
+                            to free \n
+                              delete forces[0]; \n
+                              delete forces; \n
+                            Note memory is allocated as single block of size \n
+                            3*numberOfAtoms*sizeof( float ), so only free \n
+                            'forces[0]' \n
+   @param log               log reference (stdlog in md.c)
+
+   Function calls a static method in CpuGbsa class to calculate forces/energy
+
+   Logging can be toggled by setting cpuGbsaLog to input 'log' or NULL
+
+   @return force array; energy is returned in *energy
+
+   --------------------------------------------------------------------------------------- */
+
+extern "C" float** 
+cpuCalculateGbsaForces( const rvec *atomCoordinates, const float* partialCharges, 
+                        float** forces, FILE* log ){
+
+   // ---------------------------------------------------------------------------------------
+
+   static const char* methodName             = "\ncpuCalculateGbsaForces: ";
+
+   // ---------------------------------------------------------------------------------------
+
+   // FILE* cpuGbsaLog               = NULL;
+   FILE* cpuGbsaLog               = log;
+
+   // (void) fprintf( log, "%s start", methodName );
+   // (void) fflush( log );
+
+   forces  = CpuGbsa::computeGbsaForces( atomCoordinates, partialCharges, forces, cpuGbsaLog );
+//   *energy = CpuGbsa::getCpuGbsa()->getEnergy(); 
+
+   // (void) fprintf( log, "%s done E=%.4f", methodName, *energy );
+   // (void) fflush( log );
+
+   return forces;
+
+}
+
+/**---------------------------------------------------------------------------------------
+
+   Retrieve the calculated Gbsa energy from the static class member
+
+   @return the calculated Gbsa energy from the static class member
+
+   --------------------------------------------------------------------------------------- */
+
+extern "C" float cpuGetEnergy( void ){
+   return CpuGbsa::getCpuGbsa()->getEnergy();
+}
+
+/**---------------------------------------------------------------------------------------
+
+   Delete the Gbsa associated object(s)
+
+   @return 0 if static CpuGbsa object was set; else return -1
+
+   --------------------------------------------------------------------------------------- */
+
+extern "C" int cpuDeleteGbsaParameters( void ){
+   return CpuGbsa::deleteCpuGbsa();
+}
+

platforms/reference/src/Gbsa/C-source/gmxGbsa.h

+
+/* Portions copyright (c) 2006 Stanford University and Simbios.
+ * Contributors: Pande Group
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __GmxGbsa_H__
+#define __GmxGbsa_H__
+
+// Include gromacs types
+
+#include "typedefs.h"
+
+#ifdef __cplusplus
+#define externC extern "C"
+#else
+#define externC extern
+#endif
+
+/* Set parameters for GBSA on CPU (Simbios) */
+
+externC int  
+cpuSetGbsaParameters( int numberOfAtoms, const t_topology* top, FILE* log,
+                      bool includeAceApproximation,
+                      float innerDielectric, float solventDielectric );
+
+/* Calculate GBSA forces on CPU (Simbios) (test/example) */
+
+externC float**
+cpuCalculateGbsaForces( const rvec *atomCoordinates, const float* partialCharges,
+                        float** forces, FILE* log );
+
+/* Get GBSA energy */
+
+externC float cpuGetEnergy( void );
+
+/* Delete Gbsa memory */
+
+externC int cpuDeleteGbsaParameters( void );
+
+#endif

platforms/reference/src/Gbsa/Gbsa-old-2005.sln

+
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual Studio 2005
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Gbsa", "Gbsa-old-2005.vcproj", "{519D78EF-DC26-47E3-B240-994A447774E5}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{519D78EF-DC26-47E3-B240-994A447774E5}.Debug|Win32.ActiveCfg = Debug|Win32
+		{519D78EF-DC26-47E3-B240-994A447774E5}.Debug|Win32.Build.0 = Debug|Win32
+		{519D78EF-DC26-47E3-B240-994A447774E5}.Release|Win32.ActiveCfg = Release|Win32
+		{519D78EF-DC26-47E3-B240-994A447774E5}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal