Skip to content

GitLab

Commit c6c034ba authored by Michael Sherman's avatar Michael Sherman
Browse files

Upgrade examples to track Peter's automatically-generated C and Fortran... 

Upgrade examples to track Peter's automatically-generated C and Fortran bindings. These are still using a snapshot of the wrappers, slightly hand modified, but they are much closer to the final ones now. When the automated ones are ready and part of the build, these checked-in ones will no longer be necessary.
parent 259cb45a
Show whitespace changes
Inline Side-by-side
Showing with 4610 additions and 397 deletions
examples/CMakeLists.txt
View file @ c6c034ba
......@@ -13,8 +13,9 @@
# versions of the executable.
SET(OpenMM_CWRAPPER "OpenMM_CWrapper")
SET(OpenMM_FMODULE "OpenMM_Module")
SET(OpenMM_CWRAPPER "OpenMMCWrapper")
SET(OpenMM_FWRAPPER "OpenMMFortranWrapper")
SET(OpenMM_FMODULE "OpenMMFortranModule")
# CWrapper is always a static library but you need a different
# one if you want to link with the OpenMM static library.
......@@ -35,13 +36,15 @@ SET(F_EXAMPLES HelloArgonInFortran HelloSodiumChlorideInFortran)
SET(BUILD_TESTING_SHARED 1)
SET(BUILD_TESTING_STATIC 1)
ADD_LIBRARY(${CWRAPPER_FOR_SHARED} ${OpenMM_CWRAPPER}.cpp ${OpenMM_CWRAPPER}.h)
ADD_LIBRARY(${CWRAPPER_FOR_SHARED}
${OpenMM_CWRAPPER}.cpp ${OpenMM_FWRAPPER}.cpp ${OpenMM_CWRAPPER}.h)
SET_TARGET_PROPERTIES(${CWRAPPER_FOR_SHARED}
PROPERTIES
PROJECT_LABEL "C Bindings")
TARGET_LINK_LIBRARIES(${CWRAPPER_FOR_SHARED} ${SHARED_TARGET})
ADD_LIBRARY(${CWRAPPER_FOR_STATIC} ${OpenMM_CWRAPPER}.cpp ${OpenMM_CWRAPPER}.h)
ADD_LIBRARY(${CWRAPPER_FOR_STATIC}
${OpenMM_CWRAPPER}.cpp ${OpenMM_FWRAPPER}.cpp ${OpenMM_CWRAPPER}.h)
SET_TARGET_PROPERTIES(${CWRAPPER_FOR_STATIC}
PROPERTIES
COMPILE_FLAGS "-DOPENMM_USE_STATIC_LIBRARIES"
......@@ -109,11 +112,12 @@ FOREACH(EX_ROOT ${F_EXAMPLES})
INSTALL(FILES ${EX_ROOT}.f90 DESTINATION examples)
ENDFOREACH(EX_ROOT ${F_EXAMPLES})
INSTALL(FILES ${OpenMM_CWRAPPER}.h ${OpenMM_CWRAPPER}.cpp DESTINATION examples)
INSTALL(FILES ${OpenMM_CWRAPPER}.h ${OpenMM_CWRAPPER}.cpp ${OpenMM_FWRAPPER}.cpp
DESTINATION examples)
INSTALL(FILES ${OpenMM_FMODULE}.f90 DESTINATION examples)
INSTALL(FILES README.txt DESTINATION examples)
INSTALL(FILES Makefile DESTINATION examples)
INSTALL(FILES Makefile NMakefile DESTINATION examples)
INSTALL(FILES HelloArgonVS8/HelloArgon.vcproj
HelloArgonVS8/HelloArgon.sln
......
examples/HelloArgonInC.c
View file @ c6c034ba
......@@ -11,7 +11,7 @@
* other visualization tool to produce an animation of the resulting trajectory.
* -------------------------------------------------------------------------- */
#include "OpenMM_CWrapper.h"
#include "OpenMMCWrapper.h"
#include <stdio.h>
/* Forward declaration of routine for printing one frame of the
......@@ -23,6 +23,7 @@ void simulateArgon()
OpenMM_System* system;
OpenMM_Integrator* integrator;
OpenMM_Context* context;
OpenMM_Platform* platform;
OpenMM_NonbondedForce* nonbond;
OpenMM_Vec3Array* initPosInNm;
int a, frameNum;
......@@ -41,7 +42,7 @@ void simulateArgon()
initPosInNm = OpenMM_Vec3Array_create(3);
for (a = 0; a < 3; ++a)
{
const double posNm[3] = {0.5*a, 0, 0}; /*location, nm*/
const OpenMM_Vec3 posNm = {0.5*a, 0, 0}; /*location, nm*/
OpenMM_Vec3Array_set(initPosInNm, a, posNm);
OpenMM_System_addParticle(system, 39.95); /*mass of Ar, grams/mole*/
......@@ -55,8 +56,9 @@ void simulateArgon()
/* Let OpenMM Context choose best platform. */
context = OpenMM_Context_create(system, integrator);
platform = OpenMM_Context_getPlatform(context);
printf( "REMARK Using OpenMM platform %s\n",
OpenMM_Context_getPlatformName(context));
OpenMM_Platform_getName(platform));
/* Set starting positions of the atoms. Leave time and velocity zero. */
OpenMM_Context_setPositions(context, initPosInNm);
......@@ -64,7 +66,7 @@ void simulateArgon()
/* Simulate. */
for (frameNum=1; ;++frameNum) {
/* Output current state information. */
OpenMM_State* state = OpenMM_Context_createState(context, OpenMM_State_Positions);
OpenMM_State* state = OpenMM_Context_getState(context, OpenMM_State_Positions);
const double timeInPs = OpenMM_State_getTime(state);
writePdbFrame(frameNum, state); /*output coordinates*/
OpenMM_State_destroy(state);
......@@ -99,14 +101,14 @@ void writePdbFrame(int frameNum, const OpenMM_State* state)
/* Use PDB MODEL cards to number trajectory frames. */
printf("MODEL %d\n", frameNum); /*start of frame*/
for (a = 0; a < OpenMM_Vec3Array_size(posInNm); ++a)
for (a = 0; a < OpenMM_Vec3Array_getSize(posInNm); ++a)
{
double posInAng[3];
OpenMM_Vec3 posInAng;
/* "10" here converts nanometers to Angstroms */
OpenMM_Vec3Array_getScaled(posInNm, a, 10., posInAng);
posInAng = OpenMM_Vec3_scale(*OpenMM_Vec3Array_get(posInNm, a), 10.);
printf("ATOM %5d AR AR 1 ", a+1); /*atom number*/
printf("%8.3f%8.3f%8.3f 1.00 0.00\n", /*coordinates*/
posInAng[0], posInAng[1], posInAng[2]);
posInAng.x, posInAng.y, posInAng.z);
}
printf("ENDMDL\n"); /*end of frame*/
}
examples/HelloArgonInCVS8/HelloArgonInC.vcproj
View file @ c6c034ba
......@@ -61,7 +61,7 @@
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="OpenMM_CWrapper_d.lib OpenMM_d.lib"
AdditionalDependencies="OpenMMCWrapper_d.lib OpenMM_d.lib"
LinkIncremental="2"
AdditionalLibraryDirectories="&quot;$(ProgramFiles)\OpenMM\lib&quot;"
GenerateDebugInformation="true"
......@@ -137,7 +137,7 @@
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="OpenMM_CWrapper.lib OpenMM.lib"
AdditionalDependencies="OpenMMCWrapper.lib OpenMM.lib"
LinkIncremental="1"
AdditionalLibraryDirectories="&quot;$(ProgramFiles)\OpenMM\lib&quot;"
GenerateDebugInformation="true"
......
examples/HelloArgonInFortran.f90
View file @ c6c034ba
......@@ -16,19 +16,20 @@ PROGRAM HelloArgon
type(OpenMM_System) system
type(OpenMM_VerletIntegrator) verlet
type(OpenMM_Context) context
type(OpenMM_Platform) platform
type(OpenMM_NonbondedForce) nonbond
type(OpenMM_Vec3Array) initPosInNm
type(OpenMM_State) state
type(OpenMM_String) dirName
type(OpenMM_StringArray) pluginList
real*8 timeInPs
integer*4 a, ix, frameNum
character*10 platformName
character*100 dirName
! Load any shared libraries containing GPU implementations.
call OpenMM_String_create(dirName,'')
call OpenMM_Platform_getDefaultPluginsDirectory(dirName)
call OpenMM_Platform_loadPluginsFromDirectory(dirName)
call OpenMM_String_destroy(dirName)
call OpenMM_Platform_loadPluginsFromDirectory(dirName, pluginList)
call OpenMM_StringArray_destroy(pluginList)
! Create a system with nonbonded forces. System takes ownership
! of Force; don't destroy it yourself. (We're using transfer here
......@@ -55,7 +56,8 @@ PROGRAM HelloArgon
! Let OpenMM Context choose best platform.
call OpenMM_Context_create(context, system, &
transfer(verlet, OpenMM_Integrator(0)))
call OpenMM_Context_getPlatformName(context, platformName)
call OpenMM_Context_getPlatform(context, platform)
call OpenMM_Platform_getName(platform, platformName)
print "('REMARK Using OpenMM platform ', A)", platformName
! Set starting positions of the atoms. Leave time and velocity zero.
......@@ -65,7 +67,7 @@ PROGRAM HelloArgon
frameNum = 1
do
! Output current state information.
call OpenMM_Context_createState(context, OpenMM_State_Positions, state)
call OpenMM_Context_getState(context, OpenMM_State_Positions, state)
timeInPs = OpenMM_State_getTime(state)
call writePdbFrame(frameNum, state) !output coordinates
call OpenMM_State_destroy(state)
......@@ -93,16 +95,17 @@ SUBROUTINE writePDBFrame(frameNum, state)
integer frameNum
type(OpenMM_State) state
type(OpenMM_Vec3Array) posInNm
real*8 posInAng(3)
type(OpenMM_Vec3Array) allPosInNm
real*8 posInNm(3), posInAng(3)
integer n
! Reference atomic positions in the OpenMM State.
call OpenMM_State_getPositions(state, posInNm)
call OpenMM_State_getPositions(state, allPosInNm)
print "('MODEL',5X,I0)", frameNum ! start of frame
do n = 1,OpenMM_Vec3Array_size(posInNm)
call OpenMM_Vec3Array_getScaled(posInNm, n, 10d0, posInAng)
do n = 1,OpenMM_Vec3Array_getSize(allPosInNm)
call OpenMM_Vec3Array_get(allPosInNm, n, posInNm)
call OpenMM_Vec3_scale(posInNm, 10d0, posInAng)
print "('ATOM ', I5, ' AR AR 1 ', 3F8.3, ' 1.00 0.00')", &
n, posInAng
end do
......
examples/HelloArgonInFortranVS8/HelloArgonInFortran.vfproj
View file @ c6c034ba
......@@ -5,7 +5,7 @@
<Configurations>
<Configuration Name="Debug|Win32">
<Tool Name="VFFortranCompilerTool" SuppressStartupBanner="true" DebugInformationFormat="debugEnabled" Optimization="optimizeDisabled" Interfaces="true" WarnInterfaces="true" Traceback="true" BoundsCheck="true" RuntimeLibrary="rtMultiThreadedDebugDLL"/>
<Tool Name="VFLinkerTool" LinkIncremental="linkIncrementalNo" SuppressStartupBanner="true" AdditionalLibraryDirectories="C:\Program Files\OpenMM\lib" GenerateDebugInformation="true" SubSystem="subSystemConsole" AdditionalDependencies="OpenMM_CWrapper_d.lib OpenMM_d.lib"/>
<Tool Name="VFLinkerTool" LinkIncremental="linkIncrementalNo" SuppressStartupBanner="true" AdditionalLibraryDirectories="C:\Program Files\OpenMM\lib" GenerateDebugInformation="true" SubSystem="subSystemConsole" AdditionalDependencies="OpenMMCWrapper_d.lib OpenMM_d.lib"/>
<Tool Name="VFResourceCompilerTool"/>
<Tool Name="VFMidlTool" SuppressStartupBanner="true"/>
<Tool Name="VFCustomBuildTool"/>
......@@ -15,7 +15,7 @@
<Tool Name="VFManifestTool" SuppressStartupBanner="true"/></Configuration>
<Configuration Name="Release|Win32">
<Tool Name="VFFortranCompilerTool" SuppressStartupBanner="true" RuntimeLibrary="rtMultiThreadedDLL"/>
<Tool Name="VFLinkerTool" LinkIncremental="linkIncrementalNo" SuppressStartupBanner="true" AdditionalLibraryDirectories="C:\Program Files\OpenMM\lib" SubSystem="subSystemConsole" AdditionalDependencies="OpenMM_CWrapper.lib OpenMM.lib"/>
<Tool Name="VFLinkerTool" LinkIncremental="linkIncrementalNo" SuppressStartupBanner="true" AdditionalLibraryDirectories="C:\Program Files\OpenMM\lib" SubSystem="subSystemConsole" AdditionalDependencies="OpenMMCWrapper.lib OpenMM.lib"/>
<Tool Name="VFResourceCompilerTool"/>
<Tool Name="VFMidlTool" SuppressStartupBanner="true"/>
<Tool Name="VFCustomBuildTool"/>
......@@ -28,5 +28,5 @@
<Filter Name="Resource Files" Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"/>
<Filter Name="Source Files" Filter="f90;for;f;fpp;ftn;def;odl;idl">
<File RelativePath="..\HelloArgonInFortran.f90"/>
<File RelativePath="..\OpenMM_Module.f90"/></Filter></Files>
<File RelativePath="..\OpenMMFortranModule.f90"/></Filter></Files>
<Globals/></VisualStudioProject>
examples/HelloSodiumChlorideInC.c
View file @ c6c034ba
......@@ -158,7 +158,7 @@ int main() {
* can use the implementation from the C++ version of this example if you
* want. However, the methods are reimplemented in C below in case you prefer.
*/
#include "OpenMM_CWrapper.h"
#include "OpenMMCWrapper.h"
struct MyOpenMMData_s {
......@@ -200,6 +200,7 @@ myInitializeOpenMM( const MyAtomInfo atoms[],
OpenMM_Vec3Array* initialPosInNm;
OpenMM_NonbondedForce* nonbond;
OpenMM_GBSAOBCForce* gbsa;
OpenMM_Platform* platform;
int n;
/* Load all available OpenMM plugins from their default location. */
......@@ -227,7 +228,7 @@ myInitializeOpenMM( const MyAtomInfo atoms[],
initialPosInNm = OpenMM_Vec3Array_create(0);
for (n=0; *atoms[n].pdb; ++n) {
const MyAtomInfo* atom = &atoms[n];
double posInNm[3];
OpenMM_Vec3 posInNm;
OpenMM_System_addParticle(omm->system, atom->mass);
......@@ -243,7 +244,7 @@ myInitializeOpenMM( const MyAtomInfo atoms[],
atom->gbsaScaleFactor);
/* Convert the initial position to nm and append to the array. */
OpenMM_Vec3_scale(atom->initPosInAng, OpenMM_NmPerAngstrom, posInNm);
posInNm = OpenMM_Vec3_scale(*(const OpenMM_Vec3*)atom->initPosInAng, OpenMM_NmPerAngstrom);
OpenMM_Vec3Array_append(initialPosInNm, posInNm);
}
......@@ -258,7 +259,8 @@ myInitializeOpenMM( const MyAtomInfo atoms[],
omm->context = OpenMM_Context_create(omm->system, omm->integrator);
OpenMM_Context_setPositions(omm->context, initialPosInNm);
*platformName = OpenMM_Context_getPlatformName(omm->context);
platform = OpenMM_Context_getPlatform(omm->context);
*platformName = OpenMM_Platform_getName(platform);
return omm;
}
......@@ -286,7 +288,7 @@ myGetOpenMMState(MyOpenMMData* omm, int wantEnergy,
/* Forces are also available (and cheap). */
/* State object is created here and must be explicitly destroyed below. */
state = OpenMM_Context_createState(omm->context, infoMask);
state = OpenMM_Context_getState(omm->context, infoMask);
*timeInPs = OpenMM_State_getTime(state); /* OpenMM time is in ps already. */
/* Positions are maintained as a Vec3Array inside the State. This will give
......@@ -294,8 +296,9 @@ myGetOpenMMState(MyOpenMMData* omm, int wantEnergy,
posArrayInNm = OpenMM_State_getPositions(state);
for (n=0; *atoms[n].pdb; ++n)
/* Sets atoms[n].pos = posArray[n] * Angstroms/nm. */
OpenMM_Vec3Array_getScaled(posArrayInNm, n, OpenMM_AngstromsPerNm,
atoms[n].posInAng);
*(OpenMM_Vec3*)atoms[n].posInAng =
OpenMM_Vec3_scale(*OpenMM_Vec3Array_get(posArrayInNm, n),
OpenMM_AngstromsPerNm);
/* If energy has been requested, obtain it and convert from kJ to kcal. */
*energyInKcal = 0;
......
examples/HelloSodiumChlorideInFortran.f90
View file @ c6c034ba
......@@ -180,19 +180,20 @@ SUBROUTINE myInitializeOpenMM(ommHandle, platformName)
type (OpenMM_Context) context
! These are temporary OpenMM objects used and discarded here.
type(OpenMM_Vec3Array) initialPosInNm
type(OpenMM_NonbondedForce) nonbond
type(OpenMM_GBSAOBCForce) gbsa
type (OpenMM_StringArray) pluginList
type (OpenMM_Vec3Array) initialPosInNm
type (OpenMM_NonbondedForce) nonbond
type (OpenMM_GBSAOBCForce) gbsa
type (OpenMM_Platform) platform
character*100 dirName
integer*4 n, ix
real*8 posInNm(3)
type(OpenMM_String) dir
! Create a string, get the name of the default plugins directory,
! Get the name of the default plugins directory,
! and then load all the plugins found there.
call OpenMM_String_create(dir, '')
call OpenMM_Platform_getDefaultPluginsDirectory(dir)
call OpenMM_Platform_loadPluginsFromDirectory(dir)
call OpenMM_String_destroy(dir)
call OpenMM_Platform_getDefaultPluginsDirectory(dirName)
call OpenMM_Platform_loadPluginsFromDirectory(dirName, pluginList)
call OpenMM_StringArray_destroy(pluginList)
! Create a System and Force objects for it. The System will take
! over ownership of the Forces; don't destroy them yourself.
......@@ -230,9 +231,9 @@ SUBROUTINE myInitializeOpenMM(ommHandle, platformName)
atoms(n)%gbsaScaleFactor)
! Sets initPos(n) = atoms(n)%initPos * nm/Angstrom.
call OpenMM_Vec3Array_setScaled(initialPosInNm, n, &
atoms(n)%initPosInAng, &
OpenMM_NmPerAngstrom)
call OpenMM_Vec3_scale(atoms(n)%initPosInAng, &
OpenMM_NmPerAngstrom, posInNm)
call OpenMM_Vec3Array_set(initialPosInNm, n, posInNm)
end do
! Choose an Integrator for advancing time, and a Context connecting the
......@@ -250,7 +251,8 @@ SUBROUTINE myInitializeOpenMM(ommHandle, platformName)
call OpenMM_Context_setPositions(context, initialPosInNm)
! Get the platform name to return.
call OpenMM_Context_getPlatformName(context, platformName)
call OpenMM_Context_getPlatform(context, platform)
call OpenMM_Platform_getName(platform, platformName)
! Put the System, Integrator, and Context in the RuntimeObjects
! container and return an opaque reference to the container.
......@@ -274,6 +276,7 @@ SUBROUTINE myGetOpenMMState(ommHandle, timeInPs, energyInKcal)
type (OpenMM_State) state
type (OpenMM_Vec3Array) posArrayInNm
integer infoMask, n
real*8 posInNm(3)
type (OpenMM_RuntimeObjects) omm
type (OpenMM_Context) context
......@@ -289,7 +292,7 @@ SUBROUTINE myGetOpenMMState(ommHandle, timeInPs, energyInKcal)
! Forces are also available (and cheap).
! Don't forget to destroy this State when you're done with it.
call OpenMM_Context_createState(context, infoMask, state)
call OpenMM_Context_getState(context, infoMask, state)
timeInPs = OpenMM_State_getTime(state) ! OpenMM time is in ps already.
! Positions are maintained as a Vec3Array inside the State. This will give
......@@ -297,7 +300,8 @@ SUBROUTINE myGetOpenMMState(ommHandle, timeInPs, energyInKcal)
call OpenMM_State_getPositions(state, posArrayInNm)
do n = 1, NumAtoms
! Sets atoms(n)%pos = posArray(n) * Angstroms/nm.
call OpenMM_Vec3Array_getScaled(posArrayInNm, n, OpenMM_AngstromsPerNm, &
call OpenMM_Vec3Array_get(posArrayInNm, n, posInNm)
call OpenMM_Vec3_scale(posInNm, OpenMM_AngstromsPerNm, &
atoms(n)%posInAng)
end do
......
examples/NMakefile
View file @ c6c034ba
......@@ -59,26 +59,30 @@ fortran: $(ALL_F95_EXAMPLES)
HelloArgon HelloSodiumChloride HelloEthane HelloWaterBox:
$(CC) $(CFLAGS) -I$(INCLUDE_DIR) $*.cpp /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe
HelloArgonInC: HelloArgonInC.c OpenMM_CWrapper.obj
$(CC) $(CFLAGS) -I. $*.c OpenMM_CWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe
HelloArgonInC: HelloArgonInC.c OpenMMCWrapper.obj
$(CC) $(CFLAGS) -I. $*.c OpenMMCWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe
HelloSodiumChlorideInC: HelloSodiumChlorideInC.c OpenMM_CWrapper.obj
$(CC) $(CFLAGS) -I. $*.c OpenMM_CWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe
HelloSodiumChlorideInC: HelloSodiumChlorideInC.c OpenMMCWrapper.obj
$(CC) $(CFLAGS) -I. $*.c OpenMMCWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe
HelloArgonInFortran: HelloArgonInFortran.f90 openmm.mod OpenMM_CWrapper.obj
$(FC) $(FFLAGS) $*.f90 OpenMM_CWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe
HelloArgonInFortran: HelloArgonInFortran.f90 openmm.mod OpenMMFortranWrapper.obj OpenMMCWrapper.obj
$(FC) $(FFLAGS) $*.f90 OpenMMFortranWrapper.obj OpenMMCWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe
HelloSodiumChlorideInFortran: HelloSodiumChlorideInFortran.f90 openmm.mod OpenMM_CWrapper.obj
$(FC) $(FFLAGS) $*.f90 OpenMM_CWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe
HelloSodiumChlorideInFortran: HelloSodiumChlorideInFortran.f90 openmm.mod OpenMMFortranWrapper.obj OpenMMCWrapper.obj
$(FC) $(FFLAGS) $*.f90 OpenMMFortranWrapper.obj OpenMMCWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe
# Build C Wrappers (Fortran depends on this too)
OpenMM_CWrapper.obj: OpenMM_CWrapper.cpp
$(CC) $(CFLAGS) -c -I. -I$(INCLUDE_DIR) OpenMM_CWrapper.cpp
OpenMMCWrapper.obj: OpenMMCWrapper.cpp
$(CC) $(CFLAGS) -c -I. -I$(INCLUDE_DIR) OpenMMCWrapper.cpp
# Build Fortran Wrappers
OpenMMFortranWrapper.obj: OpenMMFortranWrapper.cpp
$(CC) $(CFLAGS) -c -I. -I$(INCLUDE_DIR) OpenMMFortranWrapper.cpp
# Build Fortran 95 Module file
openmm.mod: OpenMM_Module.f90
$(FC) -c $(FFLAGS) OpenMM_Module.f90
openmm.mod: OpenMMFortranModule.f90
$(FC) -c $(FFLAGS) OpenMMFortranModule.f90
clean :
del *.mod *.obj *.exe *.pdb *.exe.manifest
......
examples/OpenMMCWrapper.cpp 0 → 100644
View file @ c6c034ba
#include "OpenMMCWrapper.h"
#include "OpenMM.h"
#include <cstring>
#include <vector>
using namespace OpenMM;
using namespace std;
#if defined(__cplusplus)
extern "C" {
#endif
/* OpenMM_Vec3 */
OpenMM_Vec3 OpenMM_Vec3_scale(const OpenMM_Vec3 vec, double scale) {
OpenMM_Vec3 result = {vec.x*scale, vec.y*scale, vec.z*scale};
return result;
}
/* OpenMM_Vec3Array */
OpenMM_Vec3Array* OpenMM_Vec3Array_create(int size) {
return reinterpret_cast<OpenMM_Vec3Array*>(new vector<Vec3>(size));
}
void OpenMM_Vec3Array_destroy(OpenMM_Vec3Array* array) {
delete reinterpret_cast<vector<Vec3>*>(array);
}
int OpenMM_Vec3Array_getSize(const OpenMM_Vec3Array* array) {
return reinterpret_cast<const vector<Vec3>*>(array)->size();
}
void OpenMM_Vec3Array_resize(OpenMM_Vec3Array* array, int size) {
reinterpret_cast<vector<Vec3>*>(array)->resize(size);
}
void OpenMM_Vec3Array_append(OpenMM_Vec3Array* array, const OpenMM_Vec3 vec) {
reinterpret_cast<vector<Vec3>*>(array)->push_back(Vec3(vec.x, vec.y, vec.z));
}
void OpenMM_Vec3Array_set(OpenMM_Vec3Array* array, int index, const OpenMM_Vec3 vec) {
(*reinterpret_cast<vector<Vec3>*>(array))[index] = Vec3(vec.x, vec.y, vec.z);
}
const OpenMM_Vec3* OpenMM_Vec3Array_get(const OpenMM_Vec3Array* array, int index) {
return reinterpret_cast<const OpenMM_Vec3*>((&(*reinterpret_cast<const vector<Vec3>*>(array))[index]));
}
/* OpenMM_StringArray */
OpenMM_StringArray* OpenMM_StringArray_create(int size) {
return reinterpret_cast<OpenMM_StringArray*>(new vector<string>(size));
}
void OpenMM_StringArray_destroy(OpenMM_StringArray* array) {
delete reinterpret_cast<vector<string>*>(array);
}
int OpenMM_StringArray_getSize(const OpenMM_StringArray* array) {
return reinterpret_cast<const vector<string>*>(array)->size();
}
void OpenMM_StringArray_resize(OpenMM_StringArray* array, int size) {
reinterpret_cast<vector<string>*>(array)->resize(size);
}
void OpenMM_StringArray_append(OpenMM_StringArray* array, const char* str) {
reinterpret_cast<vector<string>*>(array)->push_back(string(str));
}
void OpenMM_StringArray_set(OpenMM_StringArray* array, int index, const char* str) {
(*reinterpret_cast<vector<string>*>(array))[index] = string(str);
}
const char* OpenMM_StringArray_get(const OpenMM_StringArray* array, int index) {
return (*reinterpret_cast<const vector<string>*>(array))[index].c_str();
}
/* OpenMM_BondArray */
OpenMM_BondArray* OpenMM_BondArray_create(int size) {
return reinterpret_cast<OpenMM_BondArray*>(new vector<pair<int, int> >(size));
}
void OpenMM_BondArray_destroy(OpenMM_BondArray* array) {
delete reinterpret_cast<vector<pair<int, int> >*>(array);
}
int OpenMM_BondArray_getSize(const OpenMM_BondArray* array) {
return reinterpret_cast<const vector<pair<int, int> >*>(array)->size();
}
void OpenMM_BondArray_resize(OpenMM_BondArray* array, int size) {
reinterpret_cast<vector<pair<int, int> >*>(array)->resize(size);
}
void OpenMM_BondArray_append(OpenMM_BondArray* array, int particle1, int particle2) {
reinterpret_cast<vector<pair<int, int> >*>(array)->push_back(pair<int, int>(particle1, particle2));
}
void OpenMM_BondArray_set(OpenMM_BondArray* array, int index, int particle1, int particle2) {
(*reinterpret_cast<vector<pair<int, int> >*>(array))[index] = pair<int, int>(particle1, particle2);
}
void OpenMM_BondArray_get(const OpenMM_BondArray* array, int index, int* particle1, int* particle2) {
pair<int, int> particles = (*reinterpret_cast<const vector<pair<int, int> >*>(array))[index];
*particle1 = particles.first;
*particle2 = particles.second;
}
/* OpenMM_ParameterArray */
int OpenMM_ParameterArray_getSize(const OpenMM_ParameterArray* array) {
return reinterpret_cast<const map<string, double>*>(array)->size();
}
double OpenMM_ParameterArray_get(const OpenMM_ParameterArray* array, const char* name) {
const map<string, double>* params = reinterpret_cast<const map<string, double>*>(array);
const map<string, double>::const_iterator iter = params->find(string(name));
if (iter == params->end())
throw OpenMMException("OpenMM_ParameterArray_get: No such parameter");
return iter->second;
}
/* These methods need to be handled specially, since their C++ APIs cannot be directly translated to C.
Unlike the C++ versions, the return value is allocated on the heap, and you must delete it yourself. */
OpenMM_State* OpenMM_Context_getState(const OpenMM_Context* target, int types) {
State result = reinterpret_cast<const Context*>(target)->getState(types);
return reinterpret_cast<OpenMM_State*>(new State(result));
};
OpenMM_StringArray* OpenMM_Platform_loadPluginsFromDirectory(const char* directory) {
vector<string> result = Platform::loadPluginsFromDirectory(string(directory));
return reinterpret_cast<OpenMM_StringArray*>(new vector<string>(result));
};
/* OpenMM::HarmonicBondForce*/
OpenMM_HarmonicBondForce* OpenMM_HarmonicBondForce_create() {
return reinterpret_cast<OpenMM_HarmonicBondForce*>(new HarmonicBondForce());
}
void OpenMM_HarmonicBondForce_destroy(OpenMM_HarmonicBondForce* target) {
delete reinterpret_cast<HarmonicBondForce*>(target);
}
int OpenMM_HarmonicBondForce_getNumBonds(const OpenMM_HarmonicBondForce* target) {
int result = reinterpret_cast<const HarmonicBondForce*>(target)->getNumBonds();
return result;
};
int OpenMM_HarmonicBondForce_addBond(OpenMM_HarmonicBondForce* target, int particle1, int particle2, double length, double k) {
int result = reinterpret_cast<HarmonicBondForce*>(target)->addBond(particle1, particle2, length, k);
return result;
};
void OpenMM_HarmonicBondForce_getBondParameters(const OpenMM_HarmonicBondForce* target, int index, int* particle1, int* particle2, double* length, double* k) {
reinterpret_cast<const HarmonicBondForce*>(target)->getBondParameters(index, *reinterpret_cast<int* >(particle1), *reinterpret_cast<int* >(particle2), *reinterpret_cast<double* >(length), *reinterpret_cast<double* >(k));
};
void OpenMM_HarmonicBondForce_setBondParameters(OpenMM_HarmonicBondForce* target, int index, int particle1, int particle2, double length, double k) {
reinterpret_cast<HarmonicBondForce*>(target)->setBondParameters(index, particle1, particle2, length, k);
};
/* OpenMM::BrownianIntegrator*/
OpenMM_BrownianIntegrator* OpenMM_BrownianIntegrator_create(double temperature, double frictionCoeff, double stepSize) {
return reinterpret_cast<OpenMM_BrownianIntegrator*>(new BrownianIntegrator(temperature, frictionCoeff, stepSize));
}
void OpenMM_BrownianIntegrator_destroy(OpenMM_BrownianIntegrator* target) {
delete reinterpret_cast<BrownianIntegrator*>(target);
}
double OpenMM_BrownianIntegrator_getTemperature(const OpenMM_BrownianIntegrator* target) {
double result = reinterpret_cast<const BrownianIntegrator*>(target)->getTemperature();
return result;
};
void OpenMM_BrownianIntegrator_setTemperature(OpenMM_BrownianIntegrator* target, double temp) {
reinterpret_cast<BrownianIntegrator*>(target)->setTemperature(temp);
};
double OpenMM_BrownianIntegrator_getFriction(const OpenMM_BrownianIntegrator* target) {
double result = reinterpret_cast<const BrownianIntegrator*>(target)->getFriction();
return result;
};
void OpenMM_BrownianIntegrator_setFriction(OpenMM_BrownianIntegrator* target, double coeff) {
reinterpret_cast<BrownianIntegrator*>(target)->setFriction(coeff);
};
int OpenMM_BrownianIntegrator_getRandomNumberSeed(const OpenMM_BrownianIntegrator* target) {
int result = reinterpret_cast<const BrownianIntegrator*>(target)->getRandomNumberSeed();
return result;
};
void OpenMM_BrownianIntegrator_setRandomNumberSeed(OpenMM_BrownianIntegrator* target, int seed) {
reinterpret_cast<BrownianIntegrator*>(target)->setRandomNumberSeed(seed);
};
void OpenMM_BrownianIntegrator_step(OpenMM_BrownianIntegrator* target, int steps) {
reinterpret_cast<BrownianIntegrator*>(target)->step(steps);
};
/* OpenMM::OpenMMException*/
OpenMM_OpenMMException* OpenMM_OpenMMException_create(const char* message) {
return reinterpret_cast<OpenMM_OpenMMException*>(new OpenMMException(string(message)));
}
void OpenMM_OpenMMException_destroy(OpenMM_OpenMMException* target) {
delete reinterpret_cast<OpenMMException*>(target);
}
const char* OpenMM_OpenMMException_what(const OpenMM_OpenMMException* target) {
const char* result = reinterpret_cast<const OpenMMException*>(target)->what();
return reinterpret_cast<const char*>(result);
};
/* OpenMM::NonbondedForce*/
OpenMM_NonbondedForce* OpenMM_NonbondedForce_create() {
return reinterpret_cast<OpenMM_NonbondedForce*>(new NonbondedForce());
}
void OpenMM_NonbondedForce_destroy(OpenMM_NonbondedForce* target) {
delete reinterpret_cast<NonbondedForce*>(target);
}
int OpenMM_NonbondedForce_getNumParticles(const OpenMM_NonbondedForce* target) {
int result = reinterpret_cast<const NonbondedForce*>(target)->getNumParticles();
return result;
};
int OpenMM_NonbondedForce_getNumExceptions(const OpenMM_NonbondedForce* target) {
int result = reinterpret_cast<const NonbondedForce*>(target)->getNumExceptions();
return result;
};
OpenMM_NonbondedForce_NonbondedMethod OpenMM_NonbondedForce_getNonbondedMethod(const OpenMM_NonbondedForce* target) {
NonbondedForce::NonbondedMethod result = reinterpret_cast<const NonbondedForce*>(target)->getNonbondedMethod();
return static_cast<OpenMM_NonbondedForce_NonbondedMethod>(result);
};
void OpenMM_NonbondedForce_setNonbondedMethod(OpenMM_NonbondedForce* target, OpenMM_NonbondedForce_NonbondedMethod method) {
reinterpret_cast<NonbondedForce*>(target)->setNonbondedMethod(static_cast<NonbondedForce::NonbondedMethod >(method));
};
double OpenMM_NonbondedForce_getCutoffDistance(const OpenMM_NonbondedForce* target) {
double result = reinterpret_cast<const NonbondedForce*>(target)->getCutoffDistance();
return result;
};
void OpenMM_NonbondedForce_setCutoffDistance(OpenMM_NonbondedForce* target, double distance) {
reinterpret_cast<NonbondedForce*>(target)->setCutoffDistance(distance);
};
double OpenMM_NonbondedForce_getReactionFieldDielectric(const OpenMM_NonbondedForce* target) {
double result = reinterpret_cast<const NonbondedForce*>(target)->getReactionFieldDielectric();
return result;
};
void OpenMM_NonbondedForce_setReactionFieldDielectric(OpenMM_NonbondedForce* target, double dielectric) {
reinterpret_cast<NonbondedForce*>(target)->setReactionFieldDielectric(dielectric);
};
double OpenMM_NonbondedForce_getEwaldErrorTolerance(const OpenMM_NonbondedForce* target) {
double result = reinterpret_cast<const NonbondedForce*>(target)->getEwaldErrorTolerance();
return result;
};
void OpenMM_NonbondedForce_setEwaldErrorTolerance(OpenMM_NonbondedForce* target, double tol) {
reinterpret_cast<NonbondedForce*>(target)->setEwaldErrorTolerance(tol);
};
void OpenMM_NonbondedForce_getPeriodicBoxVectors(const OpenMM_NonbondedForce* target, OpenMM_Vec3* a, OpenMM_Vec3* b, OpenMM_Vec3* c) {
reinterpret_cast<const NonbondedForce*>(target)->getPeriodicBoxVectors(*reinterpret_cast<Vec3* >(a), *reinterpret_cast<Vec3* >(b), *reinterpret_cast<Vec3* >(c));
};
void OpenMM_NonbondedForce_setPeriodicBoxVectors(OpenMM_NonbondedForce* target, OpenMM_Vec3 a, OpenMM_Vec3 b, OpenMM_Vec3 c) {
reinterpret_cast<NonbondedForce*>(target)->setPeriodicBoxVectors(Vec3(a.x, a.y, a.z), Vec3(b.x, b.y, b.z), Vec3(c.x, c.y, c.z));
};
int OpenMM_NonbondedForce_addParticle(OpenMM_NonbondedForce* target, double charge, double sigma, double epsilon) {
int result = reinterpret_cast<NonbondedForce*>(target)->addParticle(charge, sigma, epsilon);
return result;
};
void OpenMM_NonbondedForce_getParticleParameters(const OpenMM_NonbondedForce* target, int index, double* charge, double* sigma, double* epsilon) {
reinterpret_cast<const NonbondedForce*>(target)->getParticleParameters(index, *reinterpret_cast<double* >(charge), *reinterpret_cast<double* >(sigma), *reinterpret_cast<double* >(epsilon));
};
void OpenMM_NonbondedForce_setParticleParameters(OpenMM_NonbondedForce* target, int index, double charge, double sigma, double epsilon) {
reinterpret_cast<NonbondedForce*>(target)->setParticleParameters(index, charge, sigma, epsilon);
};
int OpenMM_NonbondedForce_addException(OpenMM_NonbondedForce* target, int particle1, int particle2, double chargeProd, double sigma, double epsilon, OpenMM_Boolean replace) {
int result = reinterpret_cast<NonbondedForce*>(target)->addException(particle1, particle2, chargeProd, sigma, epsilon, (replace != OpenMM_False));
return result;
};
void OpenMM_NonbondedForce_getExceptionParameters(const OpenMM_NonbondedForce* target, int index, int* particle1, int* particle2, double* chargeProd, double* sigma, double* epsilon) {
reinterpret_cast<const NonbondedForce*>(target)->getExceptionParameters(index, *reinterpret_cast<int* >(particle1), *reinterpret_cast<int* >(particle2), *reinterpret_cast<double* >(chargeProd), *reinterpret_cast<double* >(sigma), *reinterpret_cast<double* >(epsilon));
};
void OpenMM_NonbondedForce_setExceptionParameters(OpenMM_NonbondedForce* target, int index, int particle1, int particle2, double chargeProd, double sigma, double epsilon) {
reinterpret_cast<NonbondedForce*>(target)->setExceptionParameters(index, particle1, particle2, chargeProd, sigma, epsilon);
};
void OpenMM_NonbondedForce_createExceptionsFromBonds(OpenMM_NonbondedForce* target, const OpenMM_BondArray* bonds, double coulomb14Scale, double lj14Scale) {
reinterpret_cast<NonbondedForce*>(target)->createExceptionsFromBonds(*reinterpret_cast<const vector<pair<int, int> >* >(bonds), coulomb14Scale, lj14Scale);
};
/* OpenMM::VariableLangevinIntegrator*/
OpenMM_VariableLangevinIntegrator* OpenMM_VariableLangevinIntegrator_create(double temperature, double frictionCoeff, double errorTol) {
return reinterpret_cast<OpenMM_VariableLangevinIntegrator*>(new VariableLangevinIntegrator(temperature, frictionCoeff, errorTol));
}
void OpenMM_VariableLangevinIntegrator_destroy(OpenMM_VariableLangevinIntegrator* target) {
delete reinterpret_cast<VariableLangevinIntegrator*>(target);
}
double OpenMM_VariableLangevinIntegrator_getTemperature(const OpenMM_VariableLangevinIntegrator* target) {
double result = reinterpret_cast<const VariableLangevinIntegrator*>(target)->getTemperature();
return result;
};
void OpenMM_VariableLangevinIntegrator_setTemperature(OpenMM_VariableLangevinIntegrator* target, double temp) {
reinterpret_cast<VariableLangevinIntegrator*>(target)->setTemperature(temp);
};
double OpenMM_VariableLangevinIntegrator_getFriction(const OpenMM_VariableLangevinIntegrator* target) {
double result = reinterpret_cast<const VariableLangevinIntegrator*>(target)->getFriction();
return result;
};
void OpenMM_VariableLangevinIntegrator_setFriction(OpenMM_VariableLangevinIntegrator* target, double coeff) {
reinterpret_cast<VariableLangevinIntegrator*>(target)->setFriction(coeff);
};
double OpenMM_VariableLangevinIntegrator_getErrorTolerance(const OpenMM_VariableLangevinIntegrator* target) {
double result = reinterpret_cast<const VariableLangevinIntegrator*>(target)->getErrorTolerance();
return result;
};
void OpenMM_VariableLangevinIntegrator_setErrorTolerance(OpenMM_VariableLangevinIntegrator* target, double tol) {
reinterpret_cast<VariableLangevinIntegrator*>(target)->setErrorTolerance(tol);
};
int OpenMM_VariableLangevinIntegrator_getRandomNumberSeed(const OpenMM_VariableLangevinIntegrator* target) {
int result = reinterpret_cast<const VariableLangevinIntegrator*>(target)->getRandomNumberSeed();
return result;
};
void OpenMM_VariableLangevinIntegrator_setRandomNumberSeed(OpenMM_VariableLangevinIntegrator* target, int seed) {
reinterpret_cast<VariableLangevinIntegrator*>(target)->setRandomNumberSeed(seed);
};
void OpenMM_VariableLangevinIntegrator_step(OpenMM_VariableLangevinIntegrator* target, int steps) {
reinterpret_cast<VariableLangevinIntegrator*>(target)->step(steps);
};
void OpenMM_VariableLangevinIntegrator_stepTo(OpenMM_VariableLangevinIntegrator* target, double time) {
reinterpret_cast<VariableLangevinIntegrator*>(target)->stepTo(time);
};
/* OpenMM::GBVIForce*/
OpenMM_GBVIForce* OpenMM_GBVIForce_create() {
return reinterpret_cast<OpenMM_GBVIForce*>(new GBVIForce());
}
void OpenMM_GBVIForce_destroy(OpenMM_GBVIForce* target) {
delete reinterpret_cast<GBVIForce*>(target);
}
int OpenMM_GBVIForce_getNumParticles(const OpenMM_GBVIForce* target) {
int result = reinterpret_cast<const GBVIForce*>(target)->getNumParticles();
return result;
};
int OpenMM_GBVIForce_addParticle(OpenMM_GBVIForce* target, double charge, double radius, double gamma) {
int result = reinterpret_cast<GBVIForce*>(target)->addParticle(charge, radius, gamma);
return result;
};
void OpenMM_GBVIForce_getParticleParameters(const OpenMM_GBVIForce* target, int index, double* charge, double* radius, double* gamma) {
reinterpret_cast<const GBVIForce*>(target)->getParticleParameters(index, *reinterpret_cast<double* >(charge), *reinterpret_cast<double* >(radius), *reinterpret_cast<double* >(gamma));
};
void OpenMM_GBVIForce_setParticleParameters(OpenMM_GBVIForce* target, int index, double charge, double radius, double gamma) {
reinterpret_cast<GBVIForce*>(target)->setParticleParameters(index, charge, radius, gamma);
};
double OpenMM_GBVIForce_getSolventDielectric(const OpenMM_GBVIForce* target) {
double result = reinterpret_cast<const GBVIForce*>(target)->getSolventDielectric();
return result;
};
void OpenMM_GBVIForce_setSolventDielectric(OpenMM_GBVIForce* target, double dielectric) {
reinterpret_cast<GBVIForce*>(target)->setSolventDielectric(dielectric);
};
double OpenMM_GBVIForce_getSoluteDielectric(const OpenMM_GBVIForce* target) {
double result = reinterpret_cast<const GBVIForce*>(target)->getSoluteDielectric();
return result;
};
void OpenMM_GBVIForce_setSoluteDielectric(OpenMM_GBVIForce* target, double dielectric) {
reinterpret_cast<GBVIForce*>(target)->setSoluteDielectric(dielectric);
};
/* OpenMM::Context*/
OpenMM_Context* OpenMM_Context_create(OpenMM_System* system, OpenMM_Integrator* integrator) {
return reinterpret_cast<OpenMM_Context*>(new Context(*reinterpret_cast<System* >(system), *reinterpret_cast<Integrator* >(integrator)));
}
OpenMM_Context* OpenMM_Context_create_2(OpenMM_System* system, OpenMM_Integrator* integrator, OpenMM_Platform* platform) {
return reinterpret_cast<OpenMM_Context*>(new Context(*reinterpret_cast<System* >(system), *reinterpret_cast<Integrator* >(integrator), *reinterpret_cast<Platform* >(platform)));
}
void OpenMM_Context_destroy(OpenMM_Context* target) {
delete reinterpret_cast<Context*>(target);
}
OpenMM_System* OpenMM_Context_getSystem(OpenMM_Context* target) {
System* result = &reinterpret_cast<Context*>(target)->getSystem();
return reinterpret_cast<OpenMM_System*>(result);
};
OpenMM_Integrator* OpenMM_Context_getIntegrator(OpenMM_Context* target) {
Integrator* result = &reinterpret_cast<Context*>(target)->getIntegrator();
return reinterpret_cast<OpenMM_Integrator*>(result);
};
OpenMM_Platform* OpenMM_Context_getPlatform(OpenMM_Context* target) {
Platform* result = &reinterpret_cast<Context*>(target)->getPlatform();
return reinterpret_cast<OpenMM_Platform*>(result);
};
void OpenMM_Context_setTime(OpenMM_Context* target, double time) {
reinterpret_cast<Context*>(target)->setTime(time);
};
void OpenMM_Context_setPositions(OpenMM_Context* target, const OpenMM_Vec3Array* positions) {
reinterpret_cast<Context*>(target)->setPositions(*reinterpret_cast<const vector<Vec3>* >(positions));
};
void OpenMM_Context_setVelocities(OpenMM_Context* target, const OpenMM_Vec3Array* velocities) {
reinterpret_cast<Context*>(target)->setVelocities(*reinterpret_cast<const vector<Vec3>* >(velocities));
};
double OpenMM_Context_getParameter(OpenMM_Context* target, const char* name) {
double result = reinterpret_cast<Context*>(target)->getParameter(string(name));
return result;
};
void OpenMM_Context_setParameter(OpenMM_Context* target, const char* name, double value) {
reinterpret_cast<Context*>(target)->setParameter(string(name), value);
};
void OpenMM_Context_reinitialize(OpenMM_Context* target) {
reinterpret_cast<Context*>(target)->reinitialize();
};
/* OpenMM::GBSAOBCForce*/
OpenMM_GBSAOBCForce* OpenMM_GBSAOBCForce_create() {
return reinterpret_cast<OpenMM_GBSAOBCForce*>(new GBSAOBCForce());
}
void OpenMM_GBSAOBCForce_destroy(OpenMM_GBSAOBCForce* target) {
delete reinterpret_cast<GBSAOBCForce*>(target);
}
int OpenMM_GBSAOBCForce_getNumParticles(const OpenMM_GBSAOBCForce* target) {
int result = reinterpret_cast<const GBSAOBCForce*>(target)->getNumParticles();
return result;
};
int OpenMM_GBSAOBCForce_addParticle(OpenMM_GBSAOBCForce* target, double charge, double radius, double scalingFactor) {
int result = reinterpret_cast<GBSAOBCForce*>(target)->addParticle(charge, radius, scalingFactor);
return result;
};
void OpenMM_GBSAOBCForce_getParticleParameters(const OpenMM_GBSAOBCForce* target, int index, double* charge, double* radius, double* scalingFactor) {
reinterpret_cast<const GBSAOBCForce*>(target)->getParticleParameters(index, *reinterpret_cast<double* >(charge), *reinterpret_cast<double* >(radius), *reinterpret_cast<double* >(scalingFactor));
};
void OpenMM_GBSAOBCForce_setParticleParameters(OpenMM_GBSAOBCForce* target, int index, double charge, double radius, double scalingFactor) {
reinterpret_cast<GBSAOBCForce*>(target)->setParticleParameters(index, charge, radius, scalingFactor);
};
double OpenMM_GBSAOBCForce_getSolventDielectric(const OpenMM_GBSAOBCForce* target) {
double result = reinterpret_cast<const GBSAOBCForce*>(target)->getSolventDielectric();
return result;
};
void OpenMM_GBSAOBCForce_setSolventDielectric(OpenMM_GBSAOBCForce* target, double dielectric) {
reinterpret_cast<GBSAOBCForce*>(target)->setSolventDielectric(dielectric);
};
double OpenMM_GBSAOBCForce_getSoluteDielectric(const OpenMM_GBSAOBCForce* target) {
double result = reinterpret_cast<const GBSAOBCForce*>(target)->getSoluteDielectric();
return result;
};
void OpenMM_GBSAOBCForce_setSoluteDielectric(OpenMM_GBSAOBCForce* target, double dielectric) {
reinterpret_cast<GBSAOBCForce*>(target)->setSoluteDielectric(dielectric);
};
/* OpenMM::VariableVerletIntegrator*/
OpenMM_VariableVerletIntegrator* OpenMM_VariableVerletIntegrator_create(double errorTol) {
return reinterpret_cast<OpenMM_VariableVerletIntegrator*>(new VariableVerletIntegrator(errorTol));
}
void OpenMM_VariableVerletIntegrator_destroy(OpenMM_VariableVerletIntegrator* target) {
delete reinterpret_cast<VariableVerletIntegrator*>(target);
}
double OpenMM_VariableVerletIntegrator_getErrorTolerance(const OpenMM_VariableVerletIntegrator* target) {
double result = reinterpret_cast<const VariableVerletIntegrator*>(target)->getErrorTolerance();
return result;
};
void OpenMM_VariableVerletIntegrator_setErrorTolerance(OpenMM_VariableVerletIntegrator* target, double tol) {
reinterpret_cast<VariableVerletIntegrator*>(target)->setErrorTolerance(tol);
};
void OpenMM_VariableVerletIntegrator_step(OpenMM_VariableVerletIntegrator* target, int steps) {
reinterpret_cast<VariableVerletIntegrator*>(target)->step(steps);
};
void OpenMM_VariableVerletIntegrator_stepTo(OpenMM_VariableVerletIntegrator* target, double time) {
reinterpret_cast<VariableVerletIntegrator*>(target)->stepTo(time);
};
/* OpenMM::CMMotionRemover*/
OpenMM_CMMotionRemover* OpenMM_CMMotionRemover_create(int frequency) {
return reinterpret_cast<OpenMM_CMMotionRemover*>(new CMMotionRemover(frequency));
}
void OpenMM_CMMotionRemover_destroy(OpenMM_CMMotionRemover* target) {
delete reinterpret_cast<CMMotionRemover*>(target);
}
int OpenMM_CMMotionRemover_getFrequency(const OpenMM_CMMotionRemover* target) {
int result = reinterpret_cast<const CMMotionRemover*>(target)->getFrequency();
return result;
};
void OpenMM_CMMotionRemover_setFrequency(OpenMM_CMMotionRemover* target, int freq) {
reinterpret_cast<CMMotionRemover*>(target)->setFrequency(freq);
};
/* OpenMM::VerletIntegrator*/
OpenMM_VerletIntegrator* OpenMM_VerletIntegrator_create(double stepSize) {
return reinterpret_cast<OpenMM_VerletIntegrator*>(new VerletIntegrator(stepSize));
}
void OpenMM_VerletIntegrator_destroy(OpenMM_VerletIntegrator* target) {
delete reinterpret_cast<VerletIntegrator*>(target);
}
void OpenMM_VerletIntegrator_step(OpenMM_VerletIntegrator* target, int steps) {
reinterpret_cast<VerletIntegrator*>(target)->step(steps);
};
/* OpenMM::RBTorsionForce*/
OpenMM_RBTorsionForce* OpenMM_RBTorsionForce_create() {
return reinterpret_cast<OpenMM_RBTorsionForce*>(new RBTorsionForce());
}
void OpenMM_RBTorsionForce_destroy(OpenMM_RBTorsionForce* target) {
delete reinterpret_cast<RBTorsionForce*>(target);
}
int OpenMM_RBTorsionForce_getNumTorsions(const OpenMM_RBTorsionForce* target) {
int result = reinterpret_cast<const RBTorsionForce*>(target)->getNumTorsions();
return result;
};
int OpenMM_RBTorsionForce_addTorsion(OpenMM_RBTorsionForce* target, int particle1, int particle2, int particle3, int particle4, double c0, double c1, double c2, double c3, double c4, double c5) {
int result = reinterpret_cast<RBTorsionForce*>(target)->addTorsion(particle1, particle2, particle3, particle4, c0, c1, c2, c3, c4, c5);
return result;
};
void OpenMM_RBTorsionForce_getTorsionParameters(const OpenMM_RBTorsionForce* target, int index, int* particle1, int* particle2, int* particle3, int* particle4, double* c0, double* c1, double* c2, double* c3, double* c4, double* c5) {
reinterpret_cast<const RBTorsionForce*>(target)->getTorsionParameters(index, *reinterpret_cast<int* >(particle1), *reinterpret_cast<int* >(particle2), *reinterpret_cast<int* >(particle3), *reinterpret_cast<int* >(particle4), *reinterpret_cast<double* >(c0), *reinterpret_cast<double* >(c1), *reinterpret_cast<double* >(c2), *reinterpret_cast<double* >(c3), *reinterpret_cast<double* >(c4), *reinterpret_cast<double* >(c5));
};
void OpenMM_RBTorsionForce_setTorsionParameters(OpenMM_RBTorsionForce* target, int index, int particle1, int particle2, int particle3, int particle4, double c0, double c1, double c2, double c3, double c4, double c5) {
reinterpret_cast<RBTorsionForce*>(target)->setTorsionParameters(index, particle1, particle2, particle3, particle4, c0, c1, c2, c3, c4, c5);
};
/* OpenMM::LangevinIntegrator*/
OpenMM_LangevinIntegrator* OpenMM_LangevinIntegrator_create(double temperature, double frictionCoeff, double stepSize) {
return reinterpret_cast<OpenMM_LangevinIntegrator*>(new LangevinIntegrator(temperature, frictionCoeff, stepSize));
}
void OpenMM_LangevinIntegrator_destroy(OpenMM_LangevinIntegrator* target) {
delete reinterpret_cast<LangevinIntegrator*>(target);
}
double OpenMM_LangevinIntegrator_getTemperature(const OpenMM_LangevinIntegrator* target) {
double result = reinterpret_cast<const LangevinIntegrator*>(target)->getTemperature();
return result;
};
void OpenMM_LangevinIntegrator_setTemperature(OpenMM_LangevinIntegrator* target, double temp) {
reinterpret_cast<LangevinIntegrator*>(target)->setTemperature(temp);
};
double OpenMM_LangevinIntegrator_getFriction(const OpenMM_LangevinIntegrator* target) {
double result = reinterpret_cast<const LangevinIntegrator*>(target)->getFriction();
return result;
};
void OpenMM_LangevinIntegrator_setFriction(OpenMM_LangevinIntegrator* target, double coeff) {
reinterpret_cast<LangevinIntegrator*>(target)->setFriction(coeff);
};
int OpenMM_LangevinIntegrator_getRandomNumberSeed(const OpenMM_LangevinIntegrator* target) {
int result = reinterpret_cast<const LangevinIntegrator*>(target)->getRandomNumberSeed();
return result;
};
void OpenMM_LangevinIntegrator_setRandomNumberSeed(OpenMM_LangevinIntegrator* target, int seed) {
reinterpret_cast<LangevinIntegrator*>(target)->setRandomNumberSeed(seed);
};
void OpenMM_LangevinIntegrator_step(OpenMM_LangevinIntegrator* target, int steps) {
reinterpret_cast<LangevinIntegrator*>(target)->step(steps);
};
/* OpenMM::Force*/
void OpenMM_Force_destroy(OpenMM_Force* target) {
delete reinterpret_cast<Force*>(target);
}
/* OpenMM::HarmonicAngleForce*/
OpenMM_HarmonicAngleForce* OpenMM_HarmonicAngleForce_create() {
return reinterpret_cast<OpenMM_HarmonicAngleForce*>(new HarmonicAngleForce());
}
void OpenMM_HarmonicAngleForce_destroy(OpenMM_HarmonicAngleForce* target) {
delete reinterpret_cast<HarmonicAngleForce*>(target);
}
int OpenMM_HarmonicAngleForce_getNumAngles(const OpenMM_HarmonicAngleForce* target) {
int result = reinterpret_cast<const HarmonicAngleForce*>(target)->getNumAngles();
return result;
};
int OpenMM_HarmonicAngleForce_addAngle(OpenMM_HarmonicAngleForce* target, int particle1, int particle2, int particle3, double angle, double k) {
int result = reinterpret_cast<HarmonicAngleForce*>(target)->addAngle(particle1, particle2, particle3, angle, k);
return result;
};
void OpenMM_HarmonicAngleForce_getAngleParameters(const OpenMM_HarmonicAngleForce* target, int index, int* particle1, int* particle2, int* particle3, double* angle, double* k) {
reinterpret_cast<const HarmonicAngleForce*>(target)->getAngleParameters(index, *reinterpret_cast<int* >(particle1), *reinterpret_cast<int* >(particle2), *reinterpret_cast<int* >(particle3), *reinterpret_cast<double* >(angle), *reinterpret_cast<double* >(k));
};
void OpenMM_HarmonicAngleForce_setAngleParameters(OpenMM_HarmonicAngleForce* target, int index, int particle1, int particle2, int particle3, double angle, double k) {
reinterpret_cast<HarmonicAngleForce*>(target)->setAngleParameters(index, particle1, particle2, particle3, angle, k);
};
/* OpenMM::AndersenThermostat*/
OpenMM_AndersenThermostat* OpenMM_AndersenThermostat_create(double defaultTemperature, double defaultCollisionFrequency) {
return reinterpret_cast<OpenMM_AndersenThermostat*>(new AndersenThermostat(defaultTemperature, defaultCollisionFrequency));
}
void OpenMM_AndersenThermostat_destroy(OpenMM_AndersenThermostat* target) {
delete reinterpret_cast<AndersenThermostat*>(target);
}
const char* OpenMM_AndersenThermostat_Temperature() {
const string* result = &AndersenThermostat::Temperature();
return result->c_str();
};
const char* OpenMM_AndersenThermostat_CollisionFrequency() {
const string* result = &AndersenThermostat::CollisionFrequency();
return result->c_str();
};
double OpenMM_AndersenThermostat_getDefaultTemperature(const OpenMM_AndersenThermostat* target) {
double result = reinterpret_cast<const AndersenThermostat*>(target)->getDefaultTemperature();
return result;
};
double OpenMM_AndersenThermostat_getDefaultCollisionFrequency(const OpenMM_AndersenThermostat* target) {
double result = reinterpret_cast<const AndersenThermostat*>(target)->getDefaultCollisionFrequency();
return result;
};
int OpenMM_AndersenThermostat_getRandomNumberSeed(const OpenMM_AndersenThermostat* target) {
int result = reinterpret_cast<const AndersenThermostat*>(target)->getRandomNumberSeed();
return result;
};
void OpenMM_AndersenThermostat_setRandomNumberSeed(OpenMM_AndersenThermostat* target, int seed) {
reinterpret_cast<AndersenThermostat*>(target)->setRandomNumberSeed(seed);
};
/* OpenMM::Platform*/
void OpenMM_Platform_destroy(OpenMM_Platform* target) {
delete reinterpret_cast<Platform*>(target);
}
const char* OpenMM_Platform_getName(const OpenMM_Platform* target) {
const string* result = &reinterpret_cast<const Platform*>(target)->getName();
return result->c_str();
};
double OpenMM_Platform_getSpeed(const OpenMM_Platform* target) {
double result = reinterpret_cast<const Platform*>(target)->getSpeed();
return result;
};
OpenMM_Boolean OpenMM_Platform_supportsDoublePrecision(const OpenMM_Platform* target) {
bool result = reinterpret_cast<const Platform*>(target)->supportsDoublePrecision();
return (result ? OpenMM_True : OpenMM_False);
};
const OpenMM_StringArray* OpenMM_Platform_getPropertyNames(OpenMM_Platform* target) {
const vector<string>* result = &reinterpret_cast<Platform*>(target)->getPropertyNames();
return reinterpret_cast<const OpenMM_StringArray*>(result);
};
const char* OpenMM_Platform_getPropertyValue(const OpenMM_Platform* target, const OpenMM_Context* context, const char* property) {
const string* result = &reinterpret_cast<const Platform*>(target)->getPropertyValue(*reinterpret_cast<const Context* >(context), string(property));
return result->c_str();
};
void OpenMM_Platform_setPropertyValue(const OpenMM_Platform* target, OpenMM_Context* context, const char* property, const char* value) {
reinterpret_cast<const Platform*>(target)->setPropertyValue(*reinterpret_cast<Context* >(context), string(property), string(value));
};
const char* OpenMM_Platform_getPropertyDefaultValue(const OpenMM_Platform* target, const char* property) {
const string* result = &reinterpret_cast<const Platform*>(target)->getPropertyDefaultValue(string(property));
return result->c_str();
};
void OpenMM_Platform_setPropertyDefaultValue(OpenMM_Platform* target, const char* property, const char* value) {
reinterpret_cast<Platform*>(target)->setPropertyDefaultValue(string(property), string(value));
};
void OpenMM_Platform_contextCreated(const OpenMM_Platform* target, OpenMM_ContextImpl* context) {
reinterpret_cast<const Platform*>(target)->contextCreated(*reinterpret_cast<ContextImpl* >(context));
};
void OpenMM_Platform_contextDestroyed(const OpenMM_Platform* target, OpenMM_ContextImpl* context) {
reinterpret_cast<const Platform*>(target)->contextDestroyed(*reinterpret_cast<ContextImpl* >(context));
};
OpenMM_Boolean OpenMM_Platform_supportsKernels(const OpenMM_Platform* target, const OpenMM_StringArray* kernelNames) {
bool result = reinterpret_cast<const Platform*>(target)->supportsKernels(*reinterpret_cast<const vector<string>* >(kernelNames));
return (result ? OpenMM_True : OpenMM_False);
};
void OpenMM_Platform_registerPlatform(OpenMM_Platform* platform) {
Platform::registerPlatform(reinterpret_cast<Platform* >(platform));
};
int OpenMM_Platform_getNumPlatforms() {
int result = Platform::getNumPlatforms();
return result;
};
OpenMM_Platform* OpenMM_Platform_getPlatform(int index) {
Platform* result = &Platform::getPlatform(index);
return reinterpret_cast<OpenMM_Platform*>(result);
};
OpenMM_Platform* OpenMM_Platform_findPlatform(const OpenMM_StringArray* kernelNames) {
Platform* result = &Platform::findPlatform(*reinterpret_cast<const vector<string>* >(kernelNames));
return reinterpret_cast<OpenMM_Platform*>(result);
};
void OpenMM_Platform_loadPluginLibrary(const char* file) {
Platform::loadPluginLibrary(string(file));
};
const char* OpenMM_Platform_getDefaultPluginsDirectory() {
const string* result = &Platform::getDefaultPluginsDirectory();
return result->c_str();
};
/* OpenMM::State*/
void OpenMM_State_destroy(OpenMM_State* target) {
delete reinterpret_cast<State*>(target);
}
double OpenMM_State_getTime(const OpenMM_State* target) {
double result = reinterpret_cast<const State*>(target)->getTime();
return result;
};
const OpenMM_Vec3Array* OpenMM_State_getPositions(const OpenMM_State* target) {
const vector<Vec3>* result = &reinterpret_cast<const State*>(target)->getPositions();
return reinterpret_cast<const OpenMM_Vec3Array*>(result);
};
const OpenMM_Vec3Array* OpenMM_State_getVelocities(const OpenMM_State* target) {
const vector<Vec3>* result = &reinterpret_cast<const State*>(target)->getVelocities();
return reinterpret_cast<const OpenMM_Vec3Array*>(result);
};
const OpenMM_Vec3Array* OpenMM_State_getForces(const OpenMM_State* target) {
const vector<Vec3>* result = &reinterpret_cast<const State*>(target)->getForces();
return reinterpret_cast<const OpenMM_Vec3Array*>(result);
};
double OpenMM_State_getKineticEnergy(const OpenMM_State* target) {
double result = reinterpret_cast<const State*>(target)->getKineticEnergy();
return result;
};
double OpenMM_State_getPotentialEnergy(const OpenMM_State* target) {
double result = reinterpret_cast<const State*>(target)->getPotentialEnergy();
return result;
};
const OpenMM_ParameterArray* OpenMM_State_getParameters(const OpenMM_State* target) {
const map<string, double>* result = &reinterpret_cast<const State*>(target)->getParameters();
return reinterpret_cast<const OpenMM_ParameterArray*>(result);
};
/* OpenMM::PeriodicTorsionForce*/
OpenMM_PeriodicTorsionForce* OpenMM_PeriodicTorsionForce_create() {
return reinterpret_cast<OpenMM_PeriodicTorsionForce*>(new PeriodicTorsionForce());
}
void OpenMM_PeriodicTorsionForce_destroy(OpenMM_PeriodicTorsionForce* target) {
delete reinterpret_cast<PeriodicTorsionForce*>(target);
}
int OpenMM_PeriodicTorsionForce_getNumTorsions(const OpenMM_PeriodicTorsionForce* target) {
int result = reinterpret_cast<const PeriodicTorsionForce*>(target)->getNumTorsions();
return result;
};
int OpenMM_PeriodicTorsionForce_addTorsion(OpenMM_PeriodicTorsionForce* target, int particle1, int particle2, int particle3, int particle4, int periodicity, double phase, double k) {
int result = reinterpret_cast<PeriodicTorsionForce*>(target)->addTorsion(particle1, particle2, particle3, particle4, periodicity, phase, k);
return result;
};
void OpenMM_PeriodicTorsionForce_getTorsionParameters(const OpenMM_PeriodicTorsionForce* target, int index, int* particle1, int* particle2, int* particle3, int* particle4, int* periodicity, double* phase, double* k) {
reinterpret_cast<const PeriodicTorsionForce*>(target)->getTorsionParameters(index, *reinterpret_cast<int* >(particle1), *reinterpret_cast<int* >(particle2), *reinterpret_cast<int* >(particle3), *reinterpret_cast<int* >(particle4), *reinterpret_cast<int* >(periodicity), *reinterpret_cast<double* >(phase), *reinterpret_cast<double* >(k));
};
void OpenMM_PeriodicTorsionForce_setTorsionParameters(OpenMM_PeriodicTorsionForce* target, int index, int particle1, int particle2, int particle3, int particle4, int periodicity, double phase, double k) {
reinterpret_cast<PeriodicTorsionForce*>(target)->setTorsionParameters(index, particle1, particle2, particle3, particle4, periodicity, phase, k);
};
/* OpenMM::Integrator*/
void OpenMM_Integrator_destroy(OpenMM_Integrator* target) {
delete reinterpret_cast<Integrator*>(target);
}
double OpenMM_Integrator_getStepSize(const OpenMM_Integrator* target) {
double result = reinterpret_cast<const Integrator*>(target)->getStepSize();
return result;
};
void OpenMM_Integrator_setStepSize(OpenMM_Integrator* target, double size) {
reinterpret_cast<Integrator*>(target)->setStepSize(size);
};
double OpenMM_Integrator_getConstraintTolerance(const OpenMM_Integrator* target) {
double result = reinterpret_cast<const Integrator*>(target)->getConstraintTolerance();
return result;
};
void OpenMM_Integrator_setConstraintTolerance(OpenMM_Integrator* target, double tol) {
reinterpret_cast<Integrator*>(target)->setConstraintTolerance(tol);
};
void OpenMM_Integrator_step(OpenMM_Integrator* target, int steps) {
reinterpret_cast<Integrator*>(target)->step(steps);
};
/* OpenMM::System*/
OpenMM_System* OpenMM_System_create() {
return reinterpret_cast<OpenMM_System*>(new System());
}
void OpenMM_System_destroy(OpenMM_System* target) {
delete reinterpret_cast<System*>(target);
}
int OpenMM_System_getNumParticles(const OpenMM_System* target) {
int result = reinterpret_cast<const System*>(target)->getNumParticles();
return result;
};
int OpenMM_System_addParticle(OpenMM_System* target, double mass) {
int result = reinterpret_cast<System*>(target)->addParticle(mass);
return result;
};
double OpenMM_System_getParticleMass(const OpenMM_System* target, int index) {
double result = reinterpret_cast<const System*>(target)->getParticleMass(index);
return result;
};
void OpenMM_System_setParticleMass(OpenMM_System* target, int index, double mass) {
reinterpret_cast<System*>(target)->setParticleMass(index, mass);
};
int OpenMM_System_getNumConstraints(const OpenMM_System* target) {
int result = reinterpret_cast<const System*>(target)->getNumConstraints();
return result;
};
int OpenMM_System_addConstraint(OpenMM_System* target, int particle1, int particle2, double distance) {
int result = reinterpret_cast<System*>(target)->addConstraint(particle1, particle2, distance);
return result;
};
void OpenMM_System_getConstraintParameters(const OpenMM_System* target, int index, int* particle1, int* particle2, double* distance) {
reinterpret_cast<const System*>(target)->getConstraintParameters(index, *reinterpret_cast<int* >(particle1), *reinterpret_cast<int* >(particle2), *reinterpret_cast<double* >(distance));
};
void OpenMM_System_setConstraintParameters(OpenMM_System* target, int index, int particle1, int particle2, double distance) {
reinterpret_cast<System*>(target)->setConstraintParameters(index, particle1, particle2, distance);
};
int OpenMM_System_addForce(OpenMM_System* target, OpenMM_Force* force) {
int result = reinterpret_cast<System*>(target)->addForce(reinterpret_cast<Force* >(force));
return result;
};
int OpenMM_System_getNumForces(const OpenMM_System* target) {
int result = reinterpret_cast<const System*>(target)->getNumForces();
return result;
};
OpenMM_Force* OpenMM_System_getForce(OpenMM_System* target, int index) {
Force* result = &reinterpret_cast<System*>(target)->getForce(index);
return reinterpret_cast<OpenMM_Force*>(result);
};
///////////////////////////
// OpenMM_RuntimeObjects //
///////////////////////////
// create
OpenMM_RuntimeObjects* OpenMM_RuntimeObjects_create() {
OpenMM_RuntimeObjects* ommrt = new OpenMM_RuntimeObjects();
ommrt->system = 0;
ommrt->integrator = 0;
ommrt->context = 0;
return ommrt;
}
void openmm_runtimeobjects_create_(OpenMM_RuntimeObjects*& ommrt)
{ ommrt = OpenMM_RuntimeObjects_create(); }
void OPENMM_RUNTIMEOBJECTS_CREATE(OpenMM_RuntimeObjects*& ommrt)
{ ommrt = OpenMM_RuntimeObjects_create(); }
// clear
void OpenMM_RuntimeObjects_clear(OpenMM_RuntimeObjects* ommrt) {
if (!ommrt) return;
OpenMM_Context_destroy(ommrt->context); ommrt->context = 0;
OpenMM_Integrator_destroy(ommrt->integrator); ommrt->integrator = 0;
OpenMM_System_destroy(ommrt->system); ommrt->system = 0;
}
void openmm_runtimeobjects_clear_(OpenMM_RuntimeObjects* const& ommrt)
{ OpenMM_RuntimeObjects_clear(ommrt); }
void OPENMM_RUNTIMEOBJECTS_CLEAR(OpenMM_RuntimeObjects* const& ommrt)
{ OpenMM_RuntimeObjects_clear(ommrt); }
// destroy
void OpenMM_RuntimeObjects_destroy(OpenMM_RuntimeObjects* ommrt)
{ OpenMM_RuntimeObjects_clear(ommrt); delete ommrt; }
void openmm_runtimeobjects_destroy_(OpenMM_RuntimeObjects*& ommrt)
{ OpenMM_RuntimeObjects_destroy(ommrt); ommrt = 0; }
void OPENMM_RUNTIMEOBJECTS_DESTROY(OpenMM_RuntimeObjects*& ommrt)
{ OpenMM_RuntimeObjects_destroy(ommrt); ommrt = 0; }
// setSystem
void OpenMM_RuntimeObjects_setSystem(OpenMM_RuntimeObjects* ommrt, OpenMM_System* sys)
{ OpenMM_System_destroy(ommrt->system); ommrt->system = sys; }
void openmm_runtimeobjects_setsystem_(OpenMM_RuntimeObjects* const& ommrt, OpenMM_System* const& sys)
{ OpenMM_RuntimeObjects_setSystem(ommrt, sys); }
void OPENMM_RUNTIMEOBJECTS_SETSYSTEM(OpenMM_RuntimeObjects* const& ommrt, OpenMM_System* const& sys)
{ OpenMM_RuntimeObjects_setSystem(ommrt, sys); }
// getSystem
OpenMM_System* OpenMM_RuntimeObjects_getSystem(OpenMM_RuntimeObjects* ommrt)
{ return ommrt->system; }
void openmm_runtimeobjects_getsystem_(OpenMM_RuntimeObjects* const& ommrt, OpenMM_System*& sys)
{ sys = OpenMM_RuntimeObjects_getSystem(ommrt); }
void OPENMM_RUNTIMEOBJECTS_GETSYSTEM(OpenMM_RuntimeObjects* const& ommrt, OpenMM_System*& sys)
{ sys = OpenMM_RuntimeObjects_getSystem(ommrt); }
// setIntegrator
void OpenMM_RuntimeObjects_setIntegrator(OpenMM_RuntimeObjects* ommrt, OpenMM_Integrator* integ)
{ OpenMM_Integrator_destroy(ommrt->integrator); ommrt->integrator = integ; }
void openmm_runtimeobjects_setintegrator_(OpenMM_RuntimeObjects* const& ommrt, OpenMM_Integrator* const& integ)
{ OpenMM_RuntimeObjects_setIntegrator(ommrt, integ); }
void OPENMM_RUNTIMEOBJECTS_SETINTEGRATOR(OpenMM_RuntimeObjects* const& ommrt, OpenMM_Integrator* const& integ)
{ OpenMM_RuntimeObjects_setIntegrator(ommrt, integ); }
// getIntegrator
OpenMM_Integrator* OpenMM_RuntimeObjects_getIntegrator(OpenMM_RuntimeObjects* ommrt)
{ return ommrt->integrator; }
void openmm_runtimeobjects_getintegrator_(OpenMM_RuntimeObjects* const& ommrt, OpenMM_Integrator*& integ)
{ integ = OpenMM_RuntimeObjects_getIntegrator(ommrt); }
void OPENMM_RUNTIMEOBJECTS_GETINTEGRATOR(OpenMM_RuntimeObjects* const& ommrt, OpenMM_Integrator*& integ)
{ integ = OpenMM_RuntimeObjects_getIntegrator(ommrt); }
// setContext
void OpenMM_RuntimeObjects_setContext(OpenMM_RuntimeObjects* ommrt, OpenMM_Context* context)
{ OpenMM_Context_destroy(ommrt->context); ommrt->context = context; }
void openmm_runtimeobjects_setcontext_(OpenMM_RuntimeObjects* const& ommrt, OpenMM_Context*& context)
{ OpenMM_RuntimeObjects_setContext(ommrt, context); }
void OPENMM_RUNTIMEOBJECTS_SETCONTEXT(OpenMM_RuntimeObjects* const& ommrt, OpenMM_Context*& context)
{ OpenMM_RuntimeObjects_setContext(ommrt, context); }
// getContext
OpenMM_Context* OpenMM_RuntimeObjects_getContext(OpenMM_RuntimeObjects* ommrt)
{ return ommrt->context; }
void openmm_runtimeobjects_getcontext_(OpenMM_RuntimeObjects* const& ommrt, OpenMM_Context*& context)
{ context = OpenMM_RuntimeObjects_getContext(ommrt); }
void OPENMM_RUNTIMEOBJECTS_GETCONTEXT(OpenMM_RuntimeObjects* const& ommrt, OpenMM_Context*& context)
{ context = OpenMM_RuntimeObjects_getContext(ommrt); }
#if defined(__cplusplus)
}
#endif
examples/OpenMMCWrapper.h 0 → 100644
View file @ c6c034ba
#ifndef OPENMM_CWRAPPER_H_
#define OPENMM_CWRAPPER_H_
/* Global Constants */
static const double OpenMM_KJPerKcal = 4.184;
static const double OpenMM_KcalPerKJ = 0.2390057361376673;
static const double OpenMM_PsPerFs = 0.001;
static const double OpenMM_AngstromsPerNm = 10;
static const double OpenMM_FsPerPs = 1000;
static const double OpenMM_RadiansPerDegree = 0.017453292519943295;
static const double OpenMM_NmPerAngstrom = 0.1;
static const double OpenMM_SigmaPerVdwRadius = 1.7817974362806785;
static const double OpenMM_VdwRadiusPerSigma = 0.5612310241546865;
static const double OpenMM_DegreesPerRadian = 57.29577951308232;
/* Type Declarations */
typedef struct OpenMM_HarmonicBondForce_struct OpenMM_HarmonicBondForce;
typedef struct OpenMM_BrownianIntegrator_struct OpenMM_BrownianIntegrator;
typedef struct OpenMM_OpenMMException_struct OpenMM_OpenMMException;
typedef struct OpenMM_NonbondedForce_struct OpenMM_NonbondedForce;
typedef struct OpenMM_VariableLangevinIntegrator_struct OpenMM_VariableLangevinIntegrator;
typedef struct OpenMM_GBVIForce_struct OpenMM_GBVIForce;
typedef struct OpenMM_Context_struct OpenMM_Context;
typedef struct OpenMM_GBSAOBCForce_struct OpenMM_GBSAOBCForce;
typedef struct OpenMM_VariableVerletIntegrator_struct OpenMM_VariableVerletIntegrator;
typedef struct OpenMM_CMMotionRemover_struct OpenMM_CMMotionRemover;
typedef struct OpenMM_VerletIntegrator_struct OpenMM_VerletIntegrator;
typedef struct OpenMM_ContextImpl_struct OpenMM_ContextImpl;
typedef struct OpenMM_RBTorsionForce_struct OpenMM_RBTorsionForce;
typedef struct OpenMM_LangevinIntegrator_struct OpenMM_LangevinIntegrator;
typedef struct OpenMM_Force_struct OpenMM_Force;
typedef struct OpenMM_HarmonicAngleForce_struct OpenMM_HarmonicAngleForce;
typedef struct OpenMM_AndersenThermostat_struct OpenMM_AndersenThermostat;
typedef struct OpenMM_ForceImpl_struct OpenMM_ForceImpl;
typedef struct OpenMM_Platform_struct OpenMM_Platform;
typedef struct OpenMM_State_struct OpenMM_State;
typedef struct OpenMM_PeriodicTorsionForce_struct OpenMM_PeriodicTorsionForce;
typedef struct OpenMM_Integrator_struct OpenMM_Integrator;
typedef struct OpenMM_System_struct OpenMM_System;
typedef struct OpenMM_Vec3Array_struct OpenMM_Vec3Array;
typedef struct OpenMM_StringArray_struct OpenMM_StringArray;
typedef struct OpenMM_BondArray_struct OpenMM_BondArray;
typedef struct OpenMM_ParameterArray_struct OpenMM_ParameterArray;
typedef struct {double x, y, z;} OpenMM_Vec3;
/* This struct collects all the runtime object pointers together to
* facilitate use of an opaque handle in high-level C or Fortran code
* that doesn't have (or want) access to OpenMM declarations. This
* does not have an equivalent in the OpenMM C++ API. */
typedef struct OpenMM_RuntimeObjects_s {
OpenMM_System* system;
OpenMM_Integrator* integrator;
OpenMM_Context* context;
} OpenMM_RuntimeObjects;
typedef enum {OpenMM_False = 0, OpenMM_True = 1} OpenMM_Boolean;
#if defined(__cplusplus)
extern "C" {
#endif
/* OpenMM_Vec3 */
extern OpenMM_Vec3 OpenMM_Vec3_scale(const OpenMM_Vec3 vec, double scale);
/* OpenMM_Vec3Array */
extern OpenMM_Vec3Array* OpenMM_Vec3Array_create(int size);
extern void OpenMM_Vec3Array_destroy(OpenMM_Vec3Array* array);
extern int OpenMM_Vec3Array_getSize(const OpenMM_Vec3Array* array);
extern void OpenMM_Vec3Array_resize(OpenMM_Vec3Array* array, int size);
extern void OpenMM_Vec3Array_append(OpenMM_Vec3Array* array, const OpenMM_Vec3 vec);
extern void OpenMM_Vec3Array_set(OpenMM_Vec3Array* array, int index, const OpenMM_Vec3 vec);
extern const OpenMM_Vec3* OpenMM_Vec3Array_get(const OpenMM_Vec3Array* array, int index);
/* OpenMM_StringArray */
extern OpenMM_StringArray* OpenMM_StringArray_create(int size);
extern void OpenMM_StringArray_destroy(OpenMM_StringArray* array);
extern int OpenMM_StringArray_getSize(const OpenMM_StringArray* array);
extern void OpenMM_StringArray_resize(OpenMM_StringArray* array, int size);
extern void OpenMM_StringArray_append(OpenMM_StringArray* array, const char* string);
extern void OpenMM_StringArray_set(OpenMM_StringArray* array, int index, const char* string);
extern const char* OpenMM_StringArray_get(const OpenMM_StringArray* array, int index);
/* OpenMM_BondArray */
extern OpenMM_BondArray* OpenMM_BondArray_create(int size);
extern void OpenMM_BondArray_destroy(OpenMM_BondArray* array);
extern int OpenMM_BondArray_getSize(const OpenMM_BondArray* array);
extern void OpenMM_BondArray_resize(OpenMM_BondArray* array, int size);
extern void OpenMM_BondArray_append(OpenMM_BondArray* array, int particle1, int particle2);
extern void OpenMM_BondArray_set(OpenMM_BondArray* array, int index, int particle1, int particle2);
extern void OpenMM_BondArray_get(const OpenMM_BondArray* array, int index, int* particle1, int* particle2);
/* OpenMM_ParameterArray */
extern int OpenMM_ParameterArray_getSize(const OpenMM_ParameterArray* array);
extern double OpenMM_ParameterArray_get(const OpenMM_ParameterArray* array, const char* name);
/* These methods need to be handled specially, since their C++ APIs cannot be directly translated to C.
Unlike the C++ versions, the return value is allocated on the heap, and you must delete it yourself. */
extern OpenMM_State* OpenMM_Context_getState(const OpenMM_Context* target, int types);
extern OpenMM_StringArray* OpenMM_Platform_loadPluginsFromDirectory(const char* directory);
/* OpenMM::HarmonicBondForce*/
extern OpenMM_HarmonicBondForce* OpenMM_HarmonicBondForce_create();
extern void OpenMM_HarmonicBondForce_destroy(OpenMM_HarmonicBondForce* target);
extern int OpenMM_HarmonicBondForce_getNumBonds(const OpenMM_HarmonicBondForce* target);
extern int OpenMM_HarmonicBondForce_addBond(OpenMM_HarmonicBondForce* target, int particle1, int particle2, double length, double k);
extern void OpenMM_HarmonicBondForce_getBondParameters(const OpenMM_HarmonicBondForce* target, int index, int* particle1, int* particle2, double* length, double* k);
extern void OpenMM_HarmonicBondForce_setBondParameters(OpenMM_HarmonicBondForce* target, int index, int particle1, int particle2, double length, double k);
/* OpenMM::BrownianIntegrator*/
extern OpenMM_BrownianIntegrator* OpenMM_BrownianIntegrator_create(double temperature, double frictionCoeff, double stepSize);
extern void OpenMM_BrownianIntegrator_destroy(OpenMM_BrownianIntegrator* target);
extern double OpenMM_BrownianIntegrator_getTemperature(const OpenMM_BrownianIntegrator* target);
extern void OpenMM_BrownianIntegrator_setTemperature(OpenMM_BrownianIntegrator* target, double temp);
extern double OpenMM_BrownianIntegrator_getFriction(const OpenMM_BrownianIntegrator* target);
extern void OpenMM_BrownianIntegrator_setFriction(OpenMM_BrownianIntegrator* target, double coeff);
extern int OpenMM_BrownianIntegrator_getRandomNumberSeed(const OpenMM_BrownianIntegrator* target);
extern void OpenMM_BrownianIntegrator_setRandomNumberSeed(OpenMM_BrownianIntegrator* target, int seed);
extern void OpenMM_BrownianIntegrator_step(OpenMM_BrownianIntegrator* target, int steps);
/* OpenMM::OpenMMException*/
extern OpenMM_OpenMMException* OpenMM_OpenMMException_create(const char* message);
extern void OpenMM_OpenMMException_destroy(OpenMM_OpenMMException* target);
extern const char* OpenMM_OpenMMException_what(const OpenMM_OpenMMException* target);
/* OpenMM::NonbondedForce*/
typedef enum {
OpenMM_NonbondedForce_NoCutoff = 0, OpenMM_NonbondedForce_CutoffNonPeriodic = 1, OpenMM_NonbondedForce_CutoffPeriodic = 2, OpenMM_NonbondedForce_Ewald = 3, OpenMM_NonbondedForce_PME = 4
} OpenMM_NonbondedForce_NonbondedMethod;
extern OpenMM_NonbondedForce* OpenMM_NonbondedForce_create();
extern void OpenMM_NonbondedForce_destroy(OpenMM_NonbondedForce* target);
extern int OpenMM_NonbondedForce_getNumParticles(const OpenMM_NonbondedForce* target);
extern int OpenMM_NonbondedForce_getNumExceptions(const OpenMM_NonbondedForce* target);
extern OpenMM_NonbondedForce_NonbondedMethod OpenMM_NonbondedForce_getNonbondedMethod(const OpenMM_NonbondedForce* target);
extern void OpenMM_NonbondedForce_setNonbondedMethod(OpenMM_NonbondedForce* target, OpenMM_NonbondedForce_NonbondedMethod method);
extern double OpenMM_NonbondedForce_getCutoffDistance(const OpenMM_NonbondedForce* target);
extern void OpenMM_NonbondedForce_setCutoffDistance(OpenMM_NonbondedForce* target, double distance);
extern double OpenMM_NonbondedForce_getReactionFieldDielectric(const OpenMM_NonbondedForce* target);
extern void OpenMM_NonbondedForce_setReactionFieldDielectric(OpenMM_NonbondedForce* target, double dielectric);
extern double OpenMM_NonbondedForce_getEwaldErrorTolerance(const OpenMM_NonbondedForce* target);
extern void OpenMM_NonbondedForce_setEwaldErrorTolerance(OpenMM_NonbondedForce* target, double tol);
extern void OpenMM_NonbondedForce_getPeriodicBoxVectors(const OpenMM_NonbondedForce* target, OpenMM_Vec3* a, OpenMM_Vec3* b, OpenMM_Vec3* c);
extern void OpenMM_NonbondedForce_setPeriodicBoxVectors(OpenMM_NonbondedForce* target, OpenMM_Vec3 a, OpenMM_Vec3 b, OpenMM_Vec3 c);
extern int OpenMM_NonbondedForce_addParticle(OpenMM_NonbondedForce* target, double charge, double sigma, double epsilon);
extern void OpenMM_NonbondedForce_getParticleParameters(const OpenMM_NonbondedForce* target, int index, double* charge, double* sigma, double* epsilon);
extern void OpenMM_NonbondedForce_setParticleParameters(OpenMM_NonbondedForce* target, int index, double charge, double sigma, double epsilon);
extern int OpenMM_NonbondedForce_addException(OpenMM_NonbondedForce* target, int particle1, int particle2, double chargeProd, double sigma, double epsilon, OpenMM_Boolean replace);
extern void OpenMM_NonbondedForce_getExceptionParameters(const OpenMM_NonbondedForce* target, int index, int* particle1, int* particle2, double* chargeProd, double* sigma, double* epsilon);
extern void OpenMM_NonbondedForce_setExceptionParameters(OpenMM_NonbondedForce* target, int index, int particle1, int particle2, double chargeProd, double sigma, double epsilon);
extern void OpenMM_NonbondedForce_createExceptionsFromBonds(OpenMM_NonbondedForce* target, const OpenMM_BondArray* bonds, double coulomb14Scale, double lj14Scale);
/* OpenMM::VariableLangevinIntegrator*/
extern OpenMM_VariableLangevinIntegrator* OpenMM_VariableLangevinIntegrator_create(double temperature, double frictionCoeff, double errorTol);
extern void OpenMM_VariableLangevinIntegrator_destroy(OpenMM_VariableLangevinIntegrator* target);
extern double OpenMM_VariableLangevinIntegrator_getTemperature(const OpenMM_VariableLangevinIntegrator* target);
extern void OpenMM_VariableLangevinIntegrator_setTemperature(OpenMM_VariableLangevinIntegrator* target, double temp);
extern double OpenMM_VariableLangevinIntegrator_getFriction(const OpenMM_VariableLangevinIntegrator* target);
extern void OpenMM_VariableLangevinIntegrator_setFriction(OpenMM_VariableLangevinIntegrator* target, double coeff);
extern double OpenMM_VariableLangevinIntegrator_getErrorTolerance(const OpenMM_VariableLangevinIntegrator* target);
extern void OpenMM_VariableLangevinIntegrator_setErrorTolerance(OpenMM_VariableLangevinIntegrator* target, double tol);
extern int OpenMM_VariableLangevinIntegrator_getRandomNumberSeed(const OpenMM_VariableLangevinIntegrator* target);
extern void OpenMM_VariableLangevinIntegrator_setRandomNumberSeed(OpenMM_VariableLangevinIntegrator* target, int seed);
extern void OpenMM_VariableLangevinIntegrator_step(OpenMM_VariableLangevinIntegrator* target, int steps);
extern void OpenMM_VariableLangevinIntegrator_stepTo(OpenMM_VariableLangevinIntegrator* target, double time);
/* OpenMM::GBVIForce*/
extern OpenMM_GBVIForce* OpenMM_GBVIForce_create();
extern void OpenMM_GBVIForce_destroy(OpenMM_GBVIForce* target);
extern int OpenMM_GBVIForce_getNumParticles(const OpenMM_GBVIForce* target);
extern int OpenMM_GBVIForce_addParticle(OpenMM_GBVIForce* target, double charge, double radius, double gamma);
extern void OpenMM_GBVIForce_getParticleParameters(const OpenMM_GBVIForce* target, int index, double* charge, double* radius, double* gamma);
extern void OpenMM_GBVIForce_setParticleParameters(OpenMM_GBVIForce* target, int index, double charge, double radius, double gamma);
extern double OpenMM_GBVIForce_getSolventDielectric(const OpenMM_GBVIForce* target);
extern void OpenMM_GBVIForce_setSolventDielectric(OpenMM_GBVIForce* target, double dielectric);
extern double OpenMM_GBVIForce_getSoluteDielectric(const OpenMM_GBVIForce* target);
extern void OpenMM_GBVIForce_setSoluteDielectric(OpenMM_GBVIForce* target, double dielectric);
/* OpenMM::Context*/
extern OpenMM_Context* OpenMM_Context_create(OpenMM_System* system, OpenMM_Integrator* integrator);
extern OpenMM_Context* OpenMM_Context_create_2(OpenMM_System* system, OpenMM_Integrator* integrator, OpenMM_Platform* platform);
extern void OpenMM_Context_destroy(OpenMM_Context* target);
extern OpenMM_System* OpenMM_Context_getSystem(OpenMM_Context* target);
extern OpenMM_Integrator* OpenMM_Context_getIntegrator(OpenMM_Context* target);
extern OpenMM_Platform* OpenMM_Context_getPlatform(OpenMM_Context* target);
extern void OpenMM_Context_setTime(OpenMM_Context* target, double time);
extern void OpenMM_Context_setPositions(OpenMM_Context* target, const OpenMM_Vec3Array* positions);
extern void OpenMM_Context_setVelocities(OpenMM_Context* target, const OpenMM_Vec3Array* velocities);
extern double OpenMM_Context_getParameter(OpenMM_Context* target, const char* name);
extern void OpenMM_Context_setParameter(OpenMM_Context* target, const char* name, double value);
extern void OpenMM_Context_reinitialize(OpenMM_Context* target);
/* OpenMM::GBSAOBCForce*/
extern OpenMM_GBSAOBCForce* OpenMM_GBSAOBCForce_create();
extern void OpenMM_GBSAOBCForce_destroy(OpenMM_GBSAOBCForce* target);
extern int OpenMM_GBSAOBCForce_getNumParticles(const OpenMM_GBSAOBCForce* target);
extern int OpenMM_GBSAOBCForce_addParticle(OpenMM_GBSAOBCForce* target, double charge, double radius, double scalingFactor);
extern void OpenMM_GBSAOBCForce_getParticleParameters(const OpenMM_GBSAOBCForce* target, int index, double* charge, double* radius, double* scalingFactor);
extern void OpenMM_GBSAOBCForce_setParticleParameters(OpenMM_GBSAOBCForce* target, int index, double charge, double radius, double scalingFactor);
extern double OpenMM_GBSAOBCForce_getSolventDielectric(const OpenMM_GBSAOBCForce* target);
extern void OpenMM_GBSAOBCForce_setSolventDielectric(OpenMM_GBSAOBCForce* target, double dielectric);
extern double OpenMM_GBSAOBCForce_getSoluteDielectric(const OpenMM_GBSAOBCForce* target);
extern void OpenMM_GBSAOBCForce_setSoluteDielectric(OpenMM_GBSAOBCForce* target, double dielectric);
/* OpenMM::VariableVerletIntegrator*/
extern OpenMM_VariableVerletIntegrator* OpenMM_VariableVerletIntegrator_create(double errorTol);
extern void OpenMM_VariableVerletIntegrator_destroy(OpenMM_VariableVerletIntegrator* target);
extern double OpenMM_VariableVerletIntegrator_getErrorTolerance(const OpenMM_VariableVerletIntegrator* target);
extern void OpenMM_VariableVerletIntegrator_setErrorTolerance(OpenMM_VariableVerletIntegrator* target, double tol);
extern void OpenMM_VariableVerletIntegrator_step(OpenMM_VariableVerletIntegrator* target, int steps);
extern void OpenMM_VariableVerletIntegrator_stepTo(OpenMM_VariableVerletIntegrator* target, double time);
/* OpenMM::CMMotionRemover*/
extern OpenMM_CMMotionRemover* OpenMM_CMMotionRemover_create(int frequency);
extern void OpenMM_CMMotionRemover_destroy(OpenMM_CMMotionRemover* target);
extern int OpenMM_CMMotionRemover_getFrequency(const OpenMM_CMMotionRemover* target);
extern void OpenMM_CMMotionRemover_setFrequency(OpenMM_CMMotionRemover* target, int freq);
/* OpenMM::VerletIntegrator*/
extern OpenMM_VerletIntegrator* OpenMM_VerletIntegrator_create(double stepSize);
extern void OpenMM_VerletIntegrator_destroy(OpenMM_VerletIntegrator* target);
extern void OpenMM_VerletIntegrator_step(OpenMM_VerletIntegrator* target, int steps);
/* OpenMM::RBTorsionForce*/
extern OpenMM_RBTorsionForce* OpenMM_RBTorsionForce_create();
extern void OpenMM_RBTorsionForce_destroy(OpenMM_RBTorsionForce* target);
extern int OpenMM_RBTorsionForce_getNumTorsions(const OpenMM_RBTorsionForce* target);
extern int OpenMM_RBTorsionForce_addTorsion(OpenMM_RBTorsionForce* target, int particle1, int particle2, int particle3, int particle4, double c0, double c1, double c2, double c3, double c4, double c5);
extern void OpenMM_RBTorsionForce_getTorsionParameters(const OpenMM_RBTorsionForce* target, int index, int* particle1, int* particle2, int* particle3, int* particle4, double* c0, double* c1, double* c2, double* c3, double* c4, double* c5);
extern void OpenMM_RBTorsionForce_setTorsionParameters(OpenMM_RBTorsionForce* target, int index, int particle1, int particle2, int particle3, int particle4, double c0, double c1, double c2, double c3, double c4, double c5);
/* OpenMM::LangevinIntegrator*/
extern OpenMM_LangevinIntegrator* OpenMM_LangevinIntegrator_create(double temperature, double frictionCoeff, double stepSize);
extern void OpenMM_LangevinIntegrator_destroy(OpenMM_LangevinIntegrator* target);
extern double OpenMM_LangevinIntegrator_getTemperature(const OpenMM_LangevinIntegrator* target);
extern void OpenMM_LangevinIntegrator_setTemperature(OpenMM_LangevinIntegrator* target, double temp);
extern double OpenMM_LangevinIntegrator_getFriction(const OpenMM_LangevinIntegrator* target);
extern void OpenMM_LangevinIntegrator_setFriction(OpenMM_LangevinIntegrator* target, double coeff);
extern int OpenMM_LangevinIntegrator_getRandomNumberSeed(const OpenMM_LangevinIntegrator* target);
extern void OpenMM_LangevinIntegrator_setRandomNumberSeed(OpenMM_LangevinIntegrator* target, int seed);
extern void OpenMM_LangevinIntegrator_step(OpenMM_LangevinIntegrator* target, int steps);
/* OpenMM::Force*/
extern void OpenMM_Force_destroy(OpenMM_Force* target);
/* OpenMM::HarmonicAngleForce*/
extern OpenMM_HarmonicAngleForce* OpenMM_HarmonicAngleForce_create();
extern void OpenMM_HarmonicAngleForce_destroy(OpenMM_HarmonicAngleForce* target);
extern int OpenMM_HarmonicAngleForce_getNumAngles(const OpenMM_HarmonicAngleForce* target);
extern int OpenMM_HarmonicAngleForce_addAngle(OpenMM_HarmonicAngleForce* target, int particle1, int particle2, int particle3, double angle, double k);
extern void OpenMM_HarmonicAngleForce_getAngleParameters(const OpenMM_HarmonicAngleForce* target, int index, int* particle1, int* particle2, int* particle3, double* angle, double* k);
extern void OpenMM_HarmonicAngleForce_setAngleParameters(OpenMM_HarmonicAngleForce* target, int index, int particle1, int particle2, int particle3, double angle, double k);
/* OpenMM::AndersenThermostat*/
extern OpenMM_AndersenThermostat* OpenMM_AndersenThermostat_create(double defaultTemperature, double defaultCollisionFrequency);
extern void OpenMM_AndersenThermostat_destroy(OpenMM_AndersenThermostat* target);
extern const char* OpenMM_AndersenThermostat_Temperature();
extern const char* OpenMM_AndersenThermostat_CollisionFrequency();
extern double OpenMM_AndersenThermostat_getDefaultTemperature(const OpenMM_AndersenThermostat* target);
extern double OpenMM_AndersenThermostat_getDefaultCollisionFrequency(const OpenMM_AndersenThermostat* target);
extern int OpenMM_AndersenThermostat_getRandomNumberSeed(const OpenMM_AndersenThermostat* target);
extern void OpenMM_AndersenThermostat_setRandomNumberSeed(OpenMM_AndersenThermostat* target, int seed);
/* OpenMM::Platform*/
extern void OpenMM_Platform_destroy(OpenMM_Platform* target);
extern const char* OpenMM_Platform_getName(const OpenMM_Platform* target);
extern double OpenMM_Platform_getSpeed(const OpenMM_Platform* target);
extern OpenMM_Boolean OpenMM_Platform_supportsDoublePrecision(const OpenMM_Platform* target);
extern const OpenMM_StringArray* OpenMM_Platform_getPropertyNames(OpenMM_Platform* target);
extern const char* OpenMM_Platform_getPropertyValue(const OpenMM_Platform* target, const OpenMM_Context* context, const char* property);
extern void OpenMM_Platform_setPropertyValue(const OpenMM_Platform* target, OpenMM_Context* context, const char* property, const char* value);
extern const char* OpenMM_Platform_getPropertyDefaultValue(const OpenMM_Platform* target, const char* property);
extern void OpenMM_Platform_setPropertyDefaultValue(OpenMM_Platform* target, const char* property, const char* value);
extern void OpenMM_Platform_contextCreated(const OpenMM_Platform* target, OpenMM_ContextImpl* context);
extern void OpenMM_Platform_contextDestroyed(const OpenMM_Platform* target, OpenMM_ContextImpl* context);
extern OpenMM_Boolean OpenMM_Platform_supportsKernels(const OpenMM_Platform* target, const OpenMM_StringArray* kernelNames);
extern void OpenMM_Platform_registerPlatform(OpenMM_Platform* platform);
extern int OpenMM_Platform_getNumPlatforms();
extern OpenMM_Platform* OpenMM_Platform_getPlatform(int index);
extern OpenMM_Platform* OpenMM_Platform_findPlatform(const OpenMM_StringArray* kernelNames);
extern void OpenMM_Platform_loadPluginLibrary(const char* file);
extern const char* OpenMM_Platform_getDefaultPluginsDirectory();
/* OpenMM::State*/
typedef enum {
OpenMM_State_Positions = 1, OpenMM_State_Velocities = 2, OpenMM_State_Forces = 4, OpenMM_State_Energy = 8, OpenMM_State_Parameters = 16
} OpenMM_State_DataType;
extern void OpenMM_State_destroy(OpenMM_State* target);
extern double OpenMM_State_getTime(const OpenMM_State* target);
extern const OpenMM_Vec3Array* OpenMM_State_getPositions(const OpenMM_State* target);
extern const OpenMM_Vec3Array* OpenMM_State_getVelocities(const OpenMM_State* target);
extern const OpenMM_Vec3Array* OpenMM_State_getForces(const OpenMM_State* target);
extern double OpenMM_State_getKineticEnergy(const OpenMM_State* target);
extern double OpenMM_State_getPotentialEnergy(const OpenMM_State* target);
extern const OpenMM_ParameterArray* OpenMM_State_getParameters(const OpenMM_State* target);
/* OpenMM::PeriodicTorsionForce*/
extern OpenMM_PeriodicTorsionForce* OpenMM_PeriodicTorsionForce_create();
extern void OpenMM_PeriodicTorsionForce_destroy(OpenMM_PeriodicTorsionForce* target);
extern int OpenMM_PeriodicTorsionForce_getNumTorsions(const OpenMM_PeriodicTorsionForce* target);
extern int OpenMM_PeriodicTorsionForce_addTorsion(OpenMM_PeriodicTorsionForce* target, int particle1, int particle2, int particle3, int particle4, int periodicity, double phase, double k);
extern void OpenMM_PeriodicTorsionForce_getTorsionParameters(const OpenMM_PeriodicTorsionForce* target, int index, int* particle1, int* particle2, int* particle3, int* particle4, int* periodicity, double* phase, double* k);
extern void OpenMM_PeriodicTorsionForce_setTorsionParameters(OpenMM_PeriodicTorsionForce* target, int index, int particle1, int particle2, int particle3, int particle4, int periodicity, double phase, double k);
/* OpenMM::Integrator*/
extern void OpenMM_Integrator_destroy(OpenMM_Integrator* target);
extern double OpenMM_Integrator_getStepSize(const OpenMM_Integrator* target);
extern void OpenMM_Integrator_setStepSize(OpenMM_Integrator* target, double size);
extern double OpenMM_Integrator_getConstraintTolerance(const OpenMM_Integrator* target);
extern void OpenMM_Integrator_setConstraintTolerance(OpenMM_Integrator* target, double tol);
extern void OpenMM_Integrator_step(OpenMM_Integrator* target, int steps);
/* OpenMM::System*/
extern OpenMM_System* OpenMM_System_create();
extern void OpenMM_System_destroy(OpenMM_System* target);
extern int OpenMM_System_getNumParticles(const OpenMM_System* target);
extern int OpenMM_System_addParticle(OpenMM_System* target, double mass);
extern double OpenMM_System_getParticleMass(const OpenMM_System* target, int index);
extern void OpenMM_System_setParticleMass(OpenMM_System* target, int index, double mass);
extern int OpenMM_System_getNumConstraints(const OpenMM_System* target);
extern int OpenMM_System_addConstraint(OpenMM_System* target, int particle1, int particle2, double distance);
extern void OpenMM_System_getConstraintParameters(const OpenMM_System* target, int index, int* particle1, int* particle2, double* distance);
extern void OpenMM_System_setConstraintParameters(OpenMM_System* target, int index, int particle1, int particle2, double distance);
extern int OpenMM_System_addForce(OpenMM_System* target, OpenMM_Force* force);
extern int OpenMM_System_getNumForces(const OpenMM_System* target);
extern OpenMM_Force* OpenMM_System_getForce(OpenMM_System* target, int index);
#if defined(__cplusplus)
}
#endif
#endif /*OPENMM_CWRAPPER_H_*/
examples/OpenMMFortranModule.f90 0 → 100644
View file @ c6c034ba
MODULE OpenMM_Types
implicit none
! Global Constants
real*8 OpenMM_KJPerKcal
real*8 OpenMM_KcalPerKJ
real*8 OpenMM_PsPerFs
real*8 OpenMM_AngstromsPerNm
real*8 OpenMM_FsPerPs
real*8 OpenMM_RadiansPerDegree
real*8 OpenMM_NmPerAngstrom
real*8 OpenMM_SigmaPerVdwRadius
real*8 OpenMM_VdwRadiusPerSigma
real*8 OpenMM_DegreesPerRadian
parameter(OpenMM_KJPerKcal=4.184)
parameter(OpenMM_KcalPerKJ=0.2390057361376673)
parameter(OpenMM_PsPerFs=0.001)
parameter(OpenMM_AngstromsPerNm=10)
parameter(OpenMM_FsPerPs=1000)
parameter(OpenMM_RadiansPerDegree=0.017453292519943295)
parameter(OpenMM_NmPerAngstrom=0.1)
parameter(OpenMM_SigmaPerVdwRadius=1.7817974362806785)
parameter(OpenMM_VdwRadiusPerSigma=0.5612310241546865)
parameter(OpenMM_DegreesPerRadian=57.29577951308232)
! This data structure can be used to hold the set of OpenMM objects
! that must persist from call to call while running a simulation.
! It contains an OpenMM_System, _Integrator, and _Context.
type OpenMM_RuntimeObjects
integer*8 :: handle = 0
end type
! Type Declarations
type OpenMM_HarmonicBondForce
integer*8 :: handle = 0
end type
type OpenMM_BrownianIntegrator
integer*8 :: handle = 0
end type
type OpenMM_OpenMMException
integer*8 :: handle = 0
end type
type OpenMM_NonbondedForce
integer*8 :: handle = 0
end type
type OpenMM_VariableLangevinIntegrator
integer*8 :: handle = 0
end type
type OpenMM_GBVIForce
integer*8 :: handle = 0
end type
type OpenMM_Context
integer*8 :: handle = 0
end type
type OpenMM_GBSAOBCForce
integer*8 :: handle = 0
end type
type OpenMM_VariableVerletIntegrator
integer*8 :: handle = 0
end type
type OpenMM_CMMotionRemover
integer*8 :: handle = 0
end type
type OpenMM_VerletIntegrator
integer*8 :: handle = 0
end type
type OpenMM_ContextImpl
integer*8 :: handle = 0
end type
type OpenMM_RBTorsionForce
integer*8 :: handle = 0
end type
type OpenMM_LangevinIntegrator
integer*8 :: handle = 0
end type
type OpenMM_Force
integer*8 :: handle = 0
end type
type OpenMM_HarmonicAngleForce
integer*8 :: handle = 0
end type
type OpenMM_AndersenThermostat
integer*8 :: handle = 0
end type
type OpenMM_ForceImpl
integer*8 :: handle = 0
end type
type OpenMM_Platform
integer*8 :: handle = 0
end type
type OpenMM_State
integer*8 :: handle = 0
end type
type OpenMM_PeriodicTorsionForce
integer*8 :: handle = 0
end type
type OpenMM_Integrator
integer*8 :: handle = 0
end type
type OpenMM_System
integer*8 :: handle = 0
end type
type OpenMM_Vec3Array
integer*8 :: handle = 0
end type
type OpenMM_StringArray
integer*8 :: handle = 0
end type
type OpenMM_BondArray
integer*8 :: handle = 0
end type
type OpenMM_ParameterArray
integer*8 :: handle = 0
end type
! Enumerations
integer*4 OpenMM_False
integer*4 OpenMM_True
parameter(OpenMM_False=0)
parameter(OpenMM_True=1)
integer*4 OpenMM_NonbondedForce_NoCutoff
integer*4 OpenMM_NonbondedForce_CutoffNonPeriodic
integer*4 OpenMM_NonbondedForce_CutoffPeriodic
integer*4 OpenMM_NonbondedForce_Ewald
integer*4 OpenMM_NonbondedForce_PME
parameter(OpenMM_NonbondedForce_NoCutoff=0)
parameter(OpenMM_NonbondedForce_CutoffNonPeriodic=1)
parameter(OpenMM_NonbondedForce_CutoffPeriodic=2)
parameter(OpenMM_NonbondedForce_Ewald=3)
parameter(OpenMM_NonbondedForce_PME=4)
integer*4 OpenMM_State_Positions
integer*4 OpenMM_State_Velocities
integer*4 OpenMM_State_Forces
integer*4 OpenMM_State_Energy
integer*4 OpenMM_State_Parameters
parameter(OpenMM_State_Positions=1)
parameter(OpenMM_State_Velocities=2)
parameter(OpenMM_State_Forces=4)
parameter(OpenMM_State_Energy=8)
parameter(OpenMM_State_Parameters=16)
END MODULE OpenMM_Types
MODULE OpenMM
use OpenMM_Types; implicit none
interface
! OpenMM_Vec3
subroutine OpenMM_Vec3_scale(vec, scale, result)
use OpenMM_Types; implicit none
real*8 vec(3)
real*8 scale
real*8 result(3)
end
! OpenMM_Vec3Array
subroutine OpenMM_Vec3Array_create(result, size)
use OpenMM_Types; implicit none
integer*4 size
type (OpenMM_Vec3Array) result
end
subroutine OpenMM_Vec3Array_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_Vec3Array) destroy
end
function OpenMM_Vec3Array_getSize(target)
use OpenMM_Types; implicit none
type (OpenMM_Vec3Array) target
integer*4 OpenMM_Vec3Array_getSize
end
subroutine OpenMM_Vec3Array_resize(target, size)
use OpenMM_Types; implicit none
type (OpenMM_Vec3Array) target
integer*4 size
end
subroutine OpenMM_Vec3Array_append(target, vec)
use OpenMM_Types; implicit none
type (OpenMM_Vec3Array) target
real*8 vec(3)
end
subroutine OpenMM_Vec3Array_set(target, index, vec)
use OpenMM_Types; implicit none
type (OpenMM_Vec3Array) target
integer*4 index
real*8 vec(3)
end
subroutine OpenMM_Vec3Array_get(target, index, result)
use OpenMM_Types; implicit none
type (OpenMM_Vec3Array) target
integer*4 index
real*8 result(3)
end
! OpenMM_StringArray
subroutine OpenMM_StringArray_create(result, size)
use OpenMM_Types; implicit none
integer*4 size
type (OpenMM_StringArray) result
end
subroutine OpenMM_StringArray_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_StringArray) destroy
end
function OpenMM_StringArray_getSize(target)
use OpenMM_Types; implicit none
type (OpenMM_StringArray) target
integer*4 OpenMM_StringArray_getSize
end
subroutine OpenMM_StringArray_resize(target, size)
use OpenMM_Types; implicit none
type (OpenMM_StringArray) target
integer*4 size
end
subroutine OpenMM_StringArray_append(target, str)
use OpenMM_Types; implicit none
type (OpenMM_StringArray) target
character(*) str
end
subroutine OpenMM_StringArray_set(target, index, str)
use OpenMM_Types; implicit none
type (OpenMM_StringArray) target
integer*4 index
character(*) str
end
subroutine OpenMM_StringArray_get(target, index, result)
use OpenMM_Types; implicit none
type (OpenMM_StringArray) target
integer*4 index
character(*) result
end
! OpenMM_BondArray
subroutine OpenMM_BondArray_create(result, size)
use OpenMM_Types; implicit none
integer*4 size
type (OpenMM_BondArray) result
end
subroutine OpenMM_BondArray_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_BondArray) destroy
end
function OpenMM_BondArray_getSize(target)
use OpenMM_Types; implicit none
type (OpenMM_BondArray) target
integer*4 OpenMM_BondArray_getSize
end
subroutine OpenMM_BondArray_resize(target, size)
use OpenMM_Types; implicit none
type (OpenMM_BondArray) target
integer*4 size
end
subroutine OpenMM_BondArray_append(target, particle1, particle2)
use OpenMM_Types; implicit none
type (OpenMM_BondArray) target
integer*4 particle1
integer*4 particle2
end
subroutine OpenMM_BondArray_set(target, index, particle1, particle2)
use OpenMM_Types; implicit none
type (OpenMM_BondArray) target
integer*4 index
integer*4 particle1
integer*4 particle2
end
subroutine OpenMM_BondArray_get(target, index, particle1, particle2)
use OpenMM_Types; implicit none
type (OpenMM_BondArray) target
integer*4 index
integer*4 particle1
integer*4 particle2
end
! OpenMM_ParameterArray
function OpenMM_ParameterArray_getSize(target)
use OpenMM_Types; implicit none
type (OpenMM_ParameterArray) target
integer*4 OpenMM_ParameterArray_getSize
end
subroutine OpenMM_ParameterArray_get(target, name, result)
use OpenMM_Types; implicit none
type (OpenMM_ParameterArray) target
character(*) name
character(*) result
end
! OpenMM::HarmonicBondForce
subroutine OpenMM_HarmonicBondForce_create(result)
use OpenMM_Types; implicit none
type (OpenMM_HarmonicBondForce) result
end
subroutine OpenMM_HarmonicBondForce_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_HarmonicBondForce) destroy
end
function OpenMM_HarmonicBondForce_getNumBonds(target)
use OpenMM_Types; implicit none
type (OpenMM_HarmonicBondForce) target
integer*4 OpenMM_HarmonicBondForce_getNumBonds
end
function OpenMM_HarmonicBondForce_addBond(target, particle1, particle2, length, k)
use OpenMM_Types; implicit none
type (OpenMM_HarmonicBondForce) target
integer*4 particle1
integer*4 particle2
real*8 length
real*8 k
integer*4 OpenMM_HarmonicBondForce_addBond
end
subroutine OpenMM_HarmonicBondForce_getBondParameters(target, index, particle1, particle2, length, k)
use OpenMM_Types; implicit none
type (OpenMM_HarmonicBondForce) target
integer*4 index
integer*4 particle1
integer*4 particle2
real*8 length
real*8 k
end
subroutine OpenMM_HarmonicBondForce_setBondParameters(target, index, particle1, particle2, length, k)
use OpenMM_Types; implicit none
type (OpenMM_HarmonicBondForce) target
integer*4 index
integer*4 particle1
integer*4 particle2
real*8 length
real*8 k
end
! OpenMM::BrownianIntegrator
subroutine OpenMM_BrownianIntegrator_create(result, temperature, frictionCoeff, stepSize)
use OpenMM_Types; implicit none
type (OpenMM_BrownianIntegrator) result
real*8 temperature
real*8 frictionCoeff
real*8 stepSize
end
subroutine OpenMM_BrownianIntegrator_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_BrownianIntegrator) destroy
end
function OpenMM_BrownianIntegrator_getTemperature(target)
use OpenMM_Types; implicit none
type (OpenMM_BrownianIntegrator) target
real*8 OpenMM_BrownianIntegrator_getTemperature
end
subroutine OpenMM_BrownianIntegrator_setTemperature(target, temp)
use OpenMM_Types; implicit none
type (OpenMM_BrownianIntegrator) target
real*8 temp
end
function OpenMM_BrownianIntegrator_getFriction(target)
use OpenMM_Types; implicit none
type (OpenMM_BrownianIntegrator) target
real*8 OpenMM_BrownianIntegrator_getFriction
end
subroutine OpenMM_BrownianIntegrator_setFriction(target, coeff)
use OpenMM_Types; implicit none
type (OpenMM_BrownianIntegrator) target
real*8 coeff
end
function OpenMM_BrownianIntegrator_getRandomNumberSeed(target)
use OpenMM_Types; implicit none
type (OpenMM_BrownianIntegrator) target
integer*4 OpenMM_BrownianIntegrator_getRandomNumberSeed
end
subroutine OpenMM_BrownianIntegrator_setRandomNumberSeed(target, seed)
use OpenMM_Types; implicit none
type (OpenMM_BrownianIntegrator) target
integer*4 seed
end
subroutine OpenMM_BrownianIntegrator_step(target, steps)
use OpenMM_Types; implicit none
type (OpenMM_BrownianIntegrator) target
integer*4 steps
end
! OpenMM::OpenMMException
subroutine OpenMM_OpenMMException_create(result, message)
use OpenMM_Types; implicit none
type (OpenMM_OpenMMException) result
character(*) message
end
subroutine OpenMM_OpenMMException_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_OpenMMException) destroy
end
subroutine OpenMM_OpenMMException_what(target, result)
use OpenMM_Types; implicit none
type (OpenMM_OpenMMException) target
character(*) result
end
! OpenMM::NonbondedForce
subroutine OpenMM_NonbondedForce_create(result)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) result
end
subroutine OpenMM_NonbondedForce_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) destroy
end
function OpenMM_NonbondedForce_getNumParticles(target)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
integer*4 OpenMM_NonbondedForce_getNumParticles
end
function OpenMM_NonbondedForce_getNumExceptions(target)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
integer*4 OpenMM_NonbondedForce_getNumExceptions
end
subroutine OpenMM_NonbondedForce_getNonbondedMethod(target, result)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
integer*4 result
end
subroutine OpenMM_NonbondedForce_setNonbondedMethod(target, method)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
integer*4 method
end
function OpenMM_NonbondedForce_getCutoffDistance(target)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
real*8 OpenMM_NonbondedForce_getCutoffDistance
end
subroutine OpenMM_NonbondedForce_setCutoffDistance(target, distance)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
real*8 distance
end
function OpenMM_NonbondedForce_getReactionFieldDielectric(target)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
real*8 OpenMM_NonbondedForce_getReactionFieldDielectric
end
subroutine OpenMM_NonbondedForce_setReactionFieldDielectric(target, dielectric)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
real*8 dielectric
end
function OpenMM_NonbondedForce_getEwaldErrorTolerance(target)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
real*8 OpenMM_NonbondedForce_getEwaldErrorTolerance
end
subroutine OpenMM_NonbondedForce_setEwaldErrorTolerance(target, tol)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
real*8 tol
end
subroutine OpenMM_NonbondedForce_getPeriodicBoxVectors(target, a, b, c)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
real*8 a(3)
real*8 b(3)
real*8 c(3)
end
subroutine OpenMM_NonbondedForce_setPeriodicBoxVectors(target, a, b, c)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
real*8 a(3)
real*8 b(3)
real*8 c(3)
end
function OpenMM_NonbondedForce_addParticle(target, charge, sigma, epsilon)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
real*8 charge
real*8 sigma
real*8 epsilon
integer*4 OpenMM_NonbondedForce_addParticle
end
subroutine OpenMM_NonbondedForce_getParticleParameters(target, index, charge, sigma, epsilon)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
integer*4 index
real*8 charge
real*8 sigma
real*8 epsilon
end
subroutine OpenMM_NonbondedForce_setParticleParameters(target, index, charge, sigma, epsilon)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
integer*4 index
real*8 charge
real*8 sigma
real*8 epsilon
end
function OpenMM_NonbondedForce_addException(target, particle1, particle2, chargeProd, sigma, epsilon, replace)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
integer*4 particle1
integer*4 particle2
real*8 chargeProd
real*8 sigma
real*8 epsilon
integer*4 replace
integer*4 OpenMM_NonbondedForce_addException
end
subroutine OpenMM_NonbondedForce_getExceptionParameters(target, index, particle1, particle2, chargeProd, sigma, epsilon)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
integer*4 index
integer*4 particle1
integer*4 particle2
real*8 chargeProd
real*8 sigma
real*8 epsilon
end
subroutine OpenMM_NonbondedForce_setExceptionParameters(target, index, particle1, particle2, chargeProd, sigma, epsilon)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
integer*4 index
integer*4 particle1
integer*4 particle2
real*8 chargeProd
real*8 sigma
real*8 epsilon
end
subroutine OpenMM_NonbondedForce_createExceptionsFromBonds(target, bonds, coulomb14Scale, lj14Scale)
use OpenMM_Types; implicit none
type (OpenMM_NonbondedForce) target
type (OpenMM_BondArray) bonds
real*8 coulomb14Scale
real*8 lj14Scale
end
! OpenMM::VariableLangevinIntegrator
subroutine OpenMM_VariableLangevinIntegrator_create(result, temperature, frictionCoeff, errorTol)
use OpenMM_Types; implicit none
type (OpenMM_VariableLangevinIntegrator) result
real*8 temperature
real*8 frictionCoeff
real*8 errorTol
end
subroutine OpenMM_VariableLangevinIntegrator_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_VariableLangevinIntegrator) destroy
end
function OpenMM_VariableLangevinIntegrator_getTemperature(target)
use OpenMM_Types; implicit none
type (OpenMM_VariableLangevinIntegrator) target
real*8 OpenMM_VariableLangevinIntegrator_getTemperature
end
subroutine OpenMM_VariableLangevinIntegrator_setTemperature(target, temp)
use OpenMM_Types; implicit none
type (OpenMM_VariableLangevinIntegrator) target
real*8 temp
end
function OpenMM_VariableLangevinIntegrator_getFriction(target)
use OpenMM_Types; implicit none
type (OpenMM_VariableLangevinIntegrator) target
real*8 OpenMM_VariableLangevinIntegrator_getFriction
end
subroutine OpenMM_VariableLangevinIntegrator_setFriction(target, coeff)
use OpenMM_Types; implicit none
type (OpenMM_VariableLangevinIntegrator) target
real*8 coeff
end
function OpenMM_VariableLangevinIntegrator_getErrorTolerance(target)
use OpenMM_Types; implicit none
type (OpenMM_VariableLangevinIntegrator) target
real*8 OpenMM_VariableLangevinIntegrator_getErrorTolerance
end
subroutine OpenMM_VariableLangevinIntegrator_setErrorTolerance(target, tol)
use OpenMM_Types; implicit none
type (OpenMM_VariableLangevinIntegrator) target
real*8 tol
end
function OpenMM_VariableLangevinIntegrator_getRandomNumberSeed(target)
use OpenMM_Types; implicit none
type (OpenMM_VariableLangevinIntegrator) target
integer*4 OpenMM_VariableLangevinIntegrator_getRandomNumberSeed
end
subroutine OpenMM_VariableLangevinIntegrator_setRandomNumberSeed(target, seed)
use OpenMM_Types; implicit none
type (OpenMM_VariableLangevinIntegrator) target
integer*4 seed
end
subroutine OpenMM_VariableLangevinIntegrator_step(target, steps)
use OpenMM_Types; implicit none
type (OpenMM_VariableLangevinIntegrator) target
integer*4 steps
end
subroutine OpenMM_VariableLangevinIntegrator_stepTo(target, time)
use OpenMM_Types; implicit none
type (OpenMM_VariableLangevinIntegrator) target
real*8 time
end
! OpenMM::GBVIForce
subroutine OpenMM_GBVIForce_create(result)
use OpenMM_Types; implicit none
type (OpenMM_GBVIForce) result
end
subroutine OpenMM_GBVIForce_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_GBVIForce) destroy
end
function OpenMM_GBVIForce_getNumParticles(target)
use OpenMM_Types; implicit none
type (OpenMM_GBVIForce) target
integer*4 OpenMM_GBVIForce_getNumParticles
end
function OpenMM_GBVIForce_addParticle(target, charge, radius, gamma)
use OpenMM_Types; implicit none
type (OpenMM_GBVIForce) target
real*8 charge
real*8 radius
real*8 gamma
integer*4 OpenMM_GBVIForce_addParticle
end
subroutine OpenMM_GBVIForce_getParticleParameters(target, index, charge, radius, gamma)
use OpenMM_Types; implicit none
type (OpenMM_GBVIForce) target
integer*4 index
real*8 charge
real*8 radius
real*8 gamma
end
subroutine OpenMM_GBVIForce_setParticleParameters(target, index, charge, radius, gamma)
use OpenMM_Types; implicit none
type (OpenMM_GBVIForce) target
integer*4 index
real*8 charge
real*8 radius
real*8 gamma
end
function OpenMM_GBVIForce_getSolventDielectric(target)
use OpenMM_Types; implicit none
type (OpenMM_GBVIForce) target
real*8 OpenMM_GBVIForce_getSolventDielectric
end
subroutine OpenMM_GBVIForce_setSolventDielectric(target, dielectric)
use OpenMM_Types; implicit none
type (OpenMM_GBVIForce) target
real*8 dielectric
end
function OpenMM_GBVIForce_getSoluteDielectric(target)
use OpenMM_Types; implicit none
type (OpenMM_GBVIForce) target
real*8 OpenMM_GBVIForce_getSoluteDielectric
end
subroutine OpenMM_GBVIForce_setSoluteDielectric(target, dielectric)
use OpenMM_Types; implicit none
type (OpenMM_GBVIForce) target
real*8 dielectric
end
! OpenMM::Context
subroutine OpenMM_Context_create(result, system, integrator)
use OpenMM_Types; implicit none
type (OpenMM_Context) result
type (OpenMM_System) system
type (OpenMM_Integrator) integrator
end
subroutine OpenMM_Context_create_2(result, system, integrator, platform)
use OpenMM_Types; implicit none
type (OpenMM_Context) result
type (OpenMM_System) system
type (OpenMM_Integrator) integrator
type (OpenMM_Platform) platform
end
subroutine OpenMM_Context_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_Context) destroy
end
subroutine OpenMM_Context_getSystem(target, result)
use OpenMM_Types; implicit none
type (OpenMM_Context) target
type (OpenMM_System) result
end
subroutine OpenMM_Context_getIntegrator(target, result)
use OpenMM_Types; implicit none
type (OpenMM_Context) target
type (OpenMM_Integrator) result
end
subroutine OpenMM_Context_getPlatform(target, result)
use OpenMM_Types; implicit none
type (OpenMM_Context) target
type (OpenMM_Platform) result
end
subroutine OpenMM_Context_getState(target, types, result)
use OpenMM_Types; implicit none
type (OpenMM_Context) target
integer*4 types
type (OpenMM_State) result
end
subroutine OpenMM_Context_setTime(target, time)
use OpenMM_Types; implicit none
type (OpenMM_Context) target
real*8 time
end
subroutine OpenMM_Context_setPositions(target, positions)
use OpenMM_Types; implicit none
type (OpenMM_Context) target
type (OpenMM_Vec3Array) positions
end
subroutine OpenMM_Context_setVelocities(target, velocities)
use OpenMM_Types; implicit none
type (OpenMM_Context) target
type (OpenMM_Vec3Array) velocities
end
function OpenMM_Context_getParameter(target, name)
use OpenMM_Types; implicit none
type (OpenMM_Context) target
character(*) name
real*8 OpenMM_Context_getParameter
end
subroutine OpenMM_Context_setParameter(target, name, value)
use OpenMM_Types; implicit none
type (OpenMM_Context) target
character(*) name
real*8 value
end
subroutine OpenMM_Context_reinitialize(target)
use OpenMM_Types; implicit none
type (OpenMM_Context) target
end
! OpenMM::GBSAOBCForce
subroutine OpenMM_GBSAOBCForce_create(result)
use OpenMM_Types; implicit none
type (OpenMM_GBSAOBCForce) result
end
subroutine OpenMM_GBSAOBCForce_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_GBSAOBCForce) destroy
end
function OpenMM_GBSAOBCForce_getNumParticles(target)
use OpenMM_Types; implicit none
type (OpenMM_GBSAOBCForce) target
integer*4 OpenMM_GBSAOBCForce_getNumParticles
end
function OpenMM_GBSAOBCForce_addParticle(target, charge, radius, scalingFactor)
use OpenMM_Types; implicit none
type (OpenMM_GBSAOBCForce) target
real*8 charge
real*8 radius
real*8 scalingFactor
integer*4 OpenMM_GBSAOBCForce_addParticle
end
subroutine OpenMM_GBSAOBCForce_getParticleParameters(target, index, charge, radius, scalingFactor)
use OpenMM_Types; implicit none
type (OpenMM_GBSAOBCForce) target
integer*4 index
real*8 charge
real*8 radius
real*8 scalingFactor
end
subroutine OpenMM_GBSAOBCForce_setParticleParameters(target, index, charge, radius, scalingFactor)
use OpenMM_Types; implicit none
type (OpenMM_GBSAOBCForce) target
integer*4 index
real*8 charge
real*8 radius
real*8 scalingFactor
end
function OpenMM_GBSAOBCForce_getSolventDielectric(target)
use OpenMM_Types; implicit none
type (OpenMM_GBSAOBCForce) target
real*8 OpenMM_GBSAOBCForce_getSolventDielectric
end
subroutine OpenMM_GBSAOBCForce_setSolventDielectric(target, dielectric)
use OpenMM_Types; implicit none
type (OpenMM_GBSAOBCForce) target
real*8 dielectric
end
function OpenMM_GBSAOBCForce_getSoluteDielectric(target)
use OpenMM_Types; implicit none
type (OpenMM_GBSAOBCForce) target
real*8 OpenMM_GBSAOBCForce_getSoluteDielectric
end
subroutine OpenMM_GBSAOBCForce_setSoluteDielectric(target, dielectric)
use OpenMM_Types; implicit none
type (OpenMM_GBSAOBCForce) target
real*8 dielectric
end
! OpenMM::VariableVerletIntegrator
subroutine OpenMM_VariableVerletIntegrator_create(result, errorTol)
use OpenMM_Types; implicit none
type (OpenMM_VariableVerletIntegrator) result
real*8 errorTol
end
subroutine OpenMM_VariableVerletIntegrator_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_VariableVerletIntegrator) destroy
end
function OpenMM_VariableVerletIntegrator_getErrorTolerance(target)
use OpenMM_Types; implicit none
type (OpenMM_VariableVerletIntegrator) target
real*8 OpenMM_VariableVerletIntegrator_getErrorTolerance
end
subroutine OpenMM_VariableVerletIntegrator_setErrorTolerance(target, tol)
use OpenMM_Types; implicit none
type (OpenMM_VariableVerletIntegrator) target
real*8 tol
end
subroutine OpenMM_VariableVerletIntegrator_step(target, steps)
use OpenMM_Types; implicit none
type (OpenMM_VariableVerletIntegrator) target
integer*4 steps
end
subroutine OpenMM_VariableVerletIntegrator_stepTo(target, time)
use OpenMM_Types; implicit none
type (OpenMM_VariableVerletIntegrator) target
real*8 time
end
! OpenMM::CMMotionRemover
subroutine OpenMM_CMMotionRemover_create(result, frequency)
use OpenMM_Types; implicit none
type (OpenMM_CMMotionRemover) result
integer*4 frequency
end
subroutine OpenMM_CMMotionRemover_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_CMMotionRemover) destroy
end
function OpenMM_CMMotionRemover_getFrequency(target)
use OpenMM_Types; implicit none
type (OpenMM_CMMotionRemover) target
integer*4 OpenMM_CMMotionRemover_getFrequency
end
subroutine OpenMM_CMMotionRemover_setFrequency(target, freq)
use OpenMM_Types; implicit none
type (OpenMM_CMMotionRemover) target
integer*4 freq
end
! OpenMM::VerletIntegrator
subroutine OpenMM_VerletIntegrator_create(result, stepSize)
use OpenMM_Types; implicit none
type (OpenMM_VerletIntegrator) result
real*8 stepSize
end
subroutine OpenMM_VerletIntegrator_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_VerletIntegrator) destroy
end
subroutine OpenMM_VerletIntegrator_step(target, steps)
use OpenMM_Types; implicit none
type (OpenMM_VerletIntegrator) target
integer*4 steps
end
! OpenMM::RBTorsionForce
subroutine OpenMM_RBTorsionForce_create(result)
use OpenMM_Types; implicit none
type (OpenMM_RBTorsionForce) result
end
subroutine OpenMM_RBTorsionForce_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_RBTorsionForce) destroy
end
function OpenMM_RBTorsionForce_getNumTorsions(target)
use OpenMM_Types; implicit none
type (OpenMM_RBTorsionForce) target
integer*4 OpenMM_RBTorsionForce_getNumTorsions
end
function OpenMM_RBTorsionForce_addTorsion(target, particle1, particle2, particle3, particle4, c0, c1, c2, c3, c4, c5)
use OpenMM_Types; implicit none
type (OpenMM_RBTorsionForce) target
integer*4 particle1
integer*4 particle2
integer*4 particle3
integer*4 particle4
real*8 c0
real*8 c1
real*8 c2
real*8 c3
real*8 c4
real*8 c5
integer*4 OpenMM_RBTorsionForce_addTorsion
end
subroutine OpenMM_RBTorsionForce_getTorsionParameters(target, index, particle1, particle2, particle3, particle4, c0, c1, c2, c3, c4, c5)
use OpenMM_Types; implicit none
type (OpenMM_RBTorsionForce) target
integer*4 index
integer*4 particle1
integer*4 particle2
integer*4 particle3
integer*4 particle4
real*8 c0
real*8 c1
real*8 c2
real*8 c3
real*8 c4
real*8 c5
end
subroutine OpenMM_RBTorsionForce_setTorsionParameters(target, index, particle1, particle2, particle3, particle4, c0, c1, c2, c3, c4, c5)
use OpenMM_Types; implicit none
type (OpenMM_RBTorsionForce) target
integer*4 index
integer*4 particle1
integer*4 particle2
integer*4 particle3
integer*4 particle4
real*8 c0
real*8 c1
real*8 c2
real*8 c3
real*8 c4
real*8 c5
end
! OpenMM::LangevinIntegrator
subroutine OpenMM_LangevinIntegrator_create(result, temperature, frictionCoeff, stepSize)
use OpenMM_Types; implicit none
type (OpenMM_LangevinIntegrator) result
real*8 temperature
real*8 frictionCoeff
real*8 stepSize
end
subroutine OpenMM_LangevinIntegrator_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_LangevinIntegrator) destroy
end
function OpenMM_LangevinIntegrator_getTemperature(target)
use OpenMM_Types; implicit none
type (OpenMM_LangevinIntegrator) target
real*8 OpenMM_LangevinIntegrator_getTemperature
end
subroutine OpenMM_LangevinIntegrator_setTemperature(target, temp)
use OpenMM_Types; implicit none
type (OpenMM_LangevinIntegrator) target
real*8 temp
end
function OpenMM_LangevinIntegrator_getFriction(target)
use OpenMM_Types; implicit none
type (OpenMM_LangevinIntegrator) target
real*8 OpenMM_LangevinIntegrator_getFriction
end
subroutine OpenMM_LangevinIntegrator_setFriction(target, coeff)
use OpenMM_Types; implicit none
type (OpenMM_LangevinIntegrator) target
real*8 coeff
end
function OpenMM_LangevinIntegrator_getRandomNumberSeed(target)
use OpenMM_Types; implicit none
type (OpenMM_LangevinIntegrator) target
integer*4 OpenMM_LangevinIntegrator_getRandomNumberSeed
end
subroutine OpenMM_LangevinIntegrator_setRandomNumberSeed(target, seed)
use OpenMM_Types; implicit none
type (OpenMM_LangevinIntegrator) target
integer*4 seed
end
subroutine OpenMM_LangevinIntegrator_step(target, steps)
use OpenMM_Types; implicit none
type (OpenMM_LangevinIntegrator) target
integer*4 steps
end
! OpenMM::Force
! OpenMM::HarmonicAngleForce
subroutine OpenMM_HarmonicAngleForce_create(result)
use OpenMM_Types; implicit none
type (OpenMM_HarmonicAngleForce) result
end
subroutine OpenMM_HarmonicAngleForce_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_HarmonicAngleForce) destroy
end
function OpenMM_HarmonicAngleForce_getNumAngles(target)
use OpenMM_Types; implicit none
type (OpenMM_HarmonicAngleForce) target
integer*4 OpenMM_HarmonicAngleForce_getNumAngles
end
function OpenMM_HarmonicAngleForce_addAngle(target, particle1, particle2, particle3, angle, k)
use OpenMM_Types; implicit none
type (OpenMM_HarmonicAngleForce) target
integer*4 particle1
integer*4 particle2
integer*4 particle3
real*8 angle
real*8 k
integer*4 OpenMM_HarmonicAngleForce_addAngle
end
subroutine OpenMM_HarmonicAngleForce_getAngleParameters(target, index, particle1, particle2, particle3, angle, k)
use OpenMM_Types; implicit none
type (OpenMM_HarmonicAngleForce) target
integer*4 index
integer*4 particle1
integer*4 particle2
integer*4 particle3
real*8 angle
real*8 k
end
subroutine OpenMM_HarmonicAngleForce_setAngleParameters(target, index, particle1, particle2, particle3, angle, k)
use OpenMM_Types; implicit none
type (OpenMM_HarmonicAngleForce) target
integer*4 index
integer*4 particle1
integer*4 particle2
integer*4 particle3
real*8 angle
real*8 k
end
! OpenMM::AndersenThermostat
subroutine OpenMM_AndersenThermostat_create(result, defaultTemperature, defaultCollisionFrequency)
use OpenMM_Types; implicit none
type (OpenMM_AndersenThermostat) result
real*8 defaultTemperature
real*8 defaultCollisionFrequency
end
subroutine OpenMM_AndersenThermostat_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_AndersenThermostat) destroy
end
subroutine OpenMM_AndersenThermostat_Temperature(result)
use OpenMM_Types; implicit none
character(*) result
end
subroutine OpenMM_AndersenThermostat_CollisionFrequency(result)
use OpenMM_Types; implicit none
character(*) result
end
function OpenMM_AndersenThermostat_getDefaultTemperature(target)
use OpenMM_Types; implicit none
type (OpenMM_AndersenThermostat) target
real*8 OpenMM_AndersenThermostat_getDefaultTemperature
end
function OpenMM_AndersenThermostat_getDefaultCollisionFrequency(target)
use OpenMM_Types; implicit none
type (OpenMM_AndersenThermostat) target
real*8 OpenMM_AndersenThermostat_getDefaultCollisionFrequency
end
function OpenMM_AndersenThermostat_getRandomNumberSeed(target)
use OpenMM_Types; implicit none
type (OpenMM_AndersenThermostat) target
integer*4 OpenMM_AndersenThermostat_getRandomNumberSeed
end
subroutine OpenMM_AndersenThermostat_setRandomNumberSeed(target, seed)
use OpenMM_Types; implicit none
type (OpenMM_AndersenThermostat) target
integer*4 seed
end
! OpenMM::Platform
subroutine OpenMM_Platform_getName(target, result)
use OpenMM_Types; implicit none
type (OpenMM_Platform) target
character(*) result
end
function OpenMM_Platform_getSpeed(target)
use OpenMM_Types; implicit none
type (OpenMM_Platform) target
real*8 OpenMM_Platform_getSpeed
end
subroutine OpenMM_Platform_supportsDoublePrecision(target, result)
use OpenMM_Types; implicit none
type (OpenMM_Platform) target
integer*4 result
end
subroutine OpenMM_Platform_getPropertyNames(target, result)
use OpenMM_Types; implicit none
type (OpenMM_Platform) target
type (OpenMM_StringArray) result
end
subroutine OpenMM_Platform_getPropertyValue(target, context, property, result)
use OpenMM_Types; implicit none
type (OpenMM_Platform) target
type (OpenMM_Context) context
character(*) property
character(*) result
end
subroutine OpenMM_Platform_setPropertyValue(target, context, property, value)
use OpenMM_Types; implicit none
type (OpenMM_Platform) target
type (OpenMM_Context) context
character(*) property
character(*) value
end
subroutine OpenMM_Platform_getPropertyDefaultValue(target, property, result)
use OpenMM_Types; implicit none
type (OpenMM_Platform) target
character(*) property
character(*) result
end
subroutine OpenMM_Platform_setPropertyDefaultValue(target, property, value)
use OpenMM_Types; implicit none
type (OpenMM_Platform) target
character(*) property
character(*) value
end
subroutine OpenMM_Platform_contextCreated(target, context)
use OpenMM_Types; implicit none
type (OpenMM_Platform) target
type (OpenMM_ContextImpl) context
end
subroutine OpenMM_Platform_contextDestroyed(target, context)
use OpenMM_Types; implicit none
type (OpenMM_Platform) target
type (OpenMM_ContextImpl) context
end
subroutine OpenMM_Platform_supportsKernels(target, kernelNames, result)
use OpenMM_Types; implicit none
type (OpenMM_Platform) target
type (OpenMM_StringArray) kernelNames
integer*4 result
end
subroutine OpenMM_Platform_registerPlatform(platform)
use OpenMM_Types; implicit none
type (OpenMM_Platform) platform
end
function OpenMM_Platform_getNumPlatforms()
use OpenMM_Types; implicit none
integer*4 OpenMM_Platform_getNumPlatforms
end
subroutine OpenMM_Platform_getPlatform(index, result)
use OpenMM_Types; implicit none
integer*4 index
type (OpenMM_Platform) result
end
subroutine OpenMM_Platform_findPlatform(kernelNames, result)
use OpenMM_Types; implicit none
type (OpenMM_StringArray) kernelNames
type (OpenMM_Platform) result
end
subroutine OpenMM_Platform_loadPluginLibrary(file)
use OpenMM_Types; implicit none
character(*) file
end
subroutine OpenMM_Platform_loadPluginsFromDirectory(directory, result)
use OpenMM_Types; implicit none
character(*) directory
type (OpenMM_StringArray) result
end
subroutine OpenMM_Platform_getDefaultPluginsDirectory(result)
use OpenMM_Types; implicit none
character(*) result
end
! OpenMM::State
subroutine OpenMM_State_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_State) destroy
end
function OpenMM_State_getTime(target)
use OpenMM_Types; implicit none
type (OpenMM_State) target
real*8 OpenMM_State_getTime
end
subroutine OpenMM_State_getPositions(target, result)
use OpenMM_Types; implicit none
type (OpenMM_State) target
type (OpenMM_Vec3Array) result
end
subroutine OpenMM_State_getVelocities(target, result)
use OpenMM_Types; implicit none
type (OpenMM_State) target
type (OpenMM_Vec3Array) result
end
subroutine OpenMM_State_getForces(target, result)
use OpenMM_Types; implicit none
type (OpenMM_State) target
type (OpenMM_Vec3Array) result
end
function OpenMM_State_getKineticEnergy(target)
use OpenMM_Types; implicit none
type (OpenMM_State) target
real*8 OpenMM_State_getKineticEnergy
end
function OpenMM_State_getPotentialEnergy(target)
use OpenMM_Types; implicit none
type (OpenMM_State) target
real*8 OpenMM_State_getPotentialEnergy
end
subroutine OpenMM_State_getParameters(target, result)
use OpenMM_Types; implicit none
type (OpenMM_State) target
type (OpenMM_ParameterArray) result
end
! OpenMM::PeriodicTorsionForce
subroutine OpenMM_PeriodicTorsionForce_create(result)
use OpenMM_Types; implicit none
type (OpenMM_PeriodicTorsionForce) result
end
subroutine OpenMM_PeriodicTorsionForce_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_PeriodicTorsionForce) destroy
end
function OpenMM_PeriodicTorsionForce_getNumTorsions(target)
use OpenMM_Types; implicit none
type (OpenMM_PeriodicTorsionForce) target
integer*4 OpenMM_PeriodicTorsionForce_getNumTorsions
end
function OpenMM_PeriodicTorsionForce_addTorsion(target, particle1, particle2, particle3, particle4, periodicity, phase, k)
use OpenMM_Types; implicit none
type (OpenMM_PeriodicTorsionForce) target
integer*4 particle1
integer*4 particle2
integer*4 particle3
integer*4 particle4
integer*4 periodicity
real*8 phase
real*8 k
integer*4 OpenMM_PeriodicTorsionForce_addTorsion
end
subroutine OpenMM_PeriodicTorsionForce_getTorsionParameters(target, index, particle1, particle2, particle3, particle4, periodicity, phase, k)
use OpenMM_Types; implicit none
type (OpenMM_PeriodicTorsionForce) target
integer*4 index
integer*4 particle1
integer*4 particle2
integer*4 particle3
integer*4 particle4
integer*4 periodicity
real*8 phase
real*8 k
end
subroutine OpenMM_PeriodicTorsionForce_setTorsionParameters(target, index, particle1, particle2, particle3, particle4, periodicity, phase, k)
use OpenMM_Types; implicit none
type (OpenMM_PeriodicTorsionForce) target
integer*4 index
integer*4 particle1
integer*4 particle2
integer*4 particle3
integer*4 particle4
integer*4 periodicity
real*8 phase
real*8 k
end
! OpenMM::Integrator
function OpenMM_Integrator_getStepSize(target)
use OpenMM_Types; implicit none
type (OpenMM_Integrator) target
real*8 OpenMM_Integrator_getStepSize
end
subroutine OpenMM_Integrator_setStepSize(target, size)
use OpenMM_Types; implicit none
type (OpenMM_Integrator) target
real*8 size
end
function OpenMM_Integrator_getConstraintTolerance(target)
use OpenMM_Types; implicit none
type (OpenMM_Integrator) target
real*8 OpenMM_Integrator_getConstraintTolerance
end
subroutine OpenMM_Integrator_setConstraintTolerance(target, tol)
use OpenMM_Types; implicit none
type (OpenMM_Integrator) target
real*8 tol
end
subroutine OpenMM_Integrator_step(target, steps)
use OpenMM_Types; implicit none
type (OpenMM_Integrator) target
integer*4 steps
end
! OpenMM::System
subroutine OpenMM_System_create(result)
use OpenMM_Types; implicit none
type (OpenMM_System) result
end
subroutine OpenMM_System_destroy(destroy)
use OpenMM_Types; implicit none
type (OpenMM_System) destroy
end
function OpenMM_System_getNumParticles(target)
use OpenMM_Types; implicit none
type (OpenMM_System) target
integer*4 OpenMM_System_getNumParticles
end
function OpenMM_System_addParticle(target, mass)
use OpenMM_Types; implicit none
type (OpenMM_System) target
real*8 mass
integer*4 OpenMM_System_addParticle
end
function OpenMM_System_getParticleMass(target, index)
use OpenMM_Types; implicit none
type (OpenMM_System) target
integer*4 index
real*8 OpenMM_System_getParticleMass
end
subroutine OpenMM_System_setParticleMass(target, index, mass)
use OpenMM_Types; implicit none
type (OpenMM_System) target
integer*4 index
real*8 mass
end
function OpenMM_System_getNumConstraints(target)
use OpenMM_Types; implicit none
type (OpenMM_System) target
integer*4 OpenMM_System_getNumConstraints
end
function OpenMM_System_addConstraint(target, particle1, particle2, distance)
use OpenMM_Types; implicit none
type (OpenMM_System) target
integer*4 particle1
integer*4 particle2
real*8 distance
integer*4 OpenMM_System_addConstraint
end
subroutine OpenMM_System_getConstraintParameters(target, index, particle1, particle2, distance)
use OpenMM_Types; implicit none
type (OpenMM_System) target
integer*4 index
integer*4 particle1
integer*4 particle2
real*8 distance
end
subroutine OpenMM_System_setConstraintParameters(target, index, particle1, particle2, distance)
use OpenMM_Types; implicit none
type (OpenMM_System) target
integer*4 index
integer*4 particle1
integer*4 particle2
real*8 distance
end
function OpenMM_System_addForce(target, force)
use OpenMM_Types; implicit none
type (OpenMM_System) target
type (OpenMM_Force) force
integer*4 OpenMM_System_addForce
end
function OpenMM_System_getNumForces(target)
use OpenMM_Types; implicit none
type (OpenMM_System) target
integer*4 OpenMM_System_getNumForces
end
subroutine OpenMM_System_getForce(target, index, result)
use OpenMM_Types; implicit none
type (OpenMM_System) target
integer*4 index
type (OpenMM_Force) result
end
! -------------------------
! OpenMM::RuntimeObjects
! -------------------------
subroutine OpenMM_RuntimeObjects_create(omm)
use OpenMM_Types; implicit none
type (OpenMM_RuntimeObjects) omm
end
subroutine OpenMM_RuntimeObjects_clear(omm)
use OpenMM_Types; implicit none
type (OpenMM_RuntimeObjects) omm
end
subroutine OpenMM_RuntimeObjects_destroy(omm)
use OpenMM_Types; implicit none
type (OpenMM_RuntimeObjects) omm
end
subroutine OpenMM_RuntimeObjects_setSystem(omm,sys)
use OpenMM_Types; implicit none
type (OpenMM_RuntimeObjects) omm
type (OpenMM_System) sys
end
subroutine OpenMM_RuntimeObjects_setIntegrator(omm,integ)
use OpenMM_Types; implicit none
type (OpenMM_RuntimeObjects) omm
type (OpenMM_Integrator) integ
end
subroutine OpenMM_RuntimeObjects_setContext(omm,context)
use OpenMM_Types; implicit none
type (OpenMM_RuntimeObjects) omm
type (OpenMM_Context) context
end
subroutine OpenMM_RuntimeObjects_getSystem(omm,sys)
use OpenMM_Types; implicit none
type (OpenMM_RuntimeObjects) omm
type (OpenMM_System) sys
end
subroutine OpenMM_RuntimeObjects_getIntegrator(omm,integ)
use OpenMM_Types; implicit none
type (OpenMM_RuntimeObjects) omm
type (OpenMM_Integrator) integ
end
subroutine OpenMM_RuntimeObjects_getContext(omm,context)
use OpenMM_Types; implicit none
type (OpenMM_RuntimeObjects) omm
type (OpenMM_Context) context
end
end interface
END MODULE OpenMM
examples/OpenMMFortranWrapper.cpp 0 → 100644
View file @ c6c034ba
#include "OpenMMCWrapper.h"
#include "OpenMM.h"
#include <cstring>
#include <vector>
using namespace OpenMM;
using namespace std;
#if defined(__cplusplus)
extern "C" {
#endif
/* OpenMM_Vec3 */
void openmm_vec3_scale_(const OpenMM_Vec3& vec, double const& scale, OpenMM_Vec3& result) {
result = OpenMM_Vec3_scale(vec, scale);
}
void OPENMM_VEC3_SCALE(const OpenMM_Vec3& vec, double const& scale, OpenMM_Vec3& result) {
result = OpenMM_Vec3_scale(vec, scale);
}
/* OpenMM_Vec3Array */
void openmm_vec3array_create_(OpenMM_Vec3Array*& result, const int& size) {
result = OpenMM_Vec3Array_create(size);
}
void OPENMM_VEC3ARRAY_CREATE(OpenMM_Vec3Array*& result, const int& size) {
result = OpenMM_Vec3Array_create(size);
}
void openmm_vec3array_destroy_(OpenMM_Vec3Array*& array) {
OpenMM_Vec3Array_destroy(array);
array = 0;
}
void OPENMM_VEC3ARRAY_DESTROY(OpenMM_Vec3Array*& array) {
OpenMM_Vec3Array_destroy(array);
array = 0;
}
int openmm_vec3array_getsize_(const OpenMM_Vec3Array* const& array) {
return OpenMM_Vec3Array_getSize(array);
}
int OPENMM_VEC3ARRAY_GETSIZE(const OpenMM_Vec3Array* const& array) {
return OpenMM_Vec3Array_getSize(array);
}
void openmm_vec3array_resize_(OpenMM_Vec3Array* const& array, const int& size) {
OpenMM_Vec3Array_resize(array, size);
}
void OPENMM_VEC3ARRAY_RESIZE(OpenMM_Vec3Array* const& array, const int& size) {
OpenMM_Vec3Array_resize(array, size);
}
void openmm_vec3array_append_(OpenMM_Vec3Array* const& array, const OpenMM_Vec3& vec) {
OpenMM_Vec3Array_append(array, vec);
}
void OPENMM_VEC3ARRAY_APPEND(OpenMM_Vec3Array* const& array, const OpenMM_Vec3& vec) {
OpenMM_Vec3Array_append(array, vec);
}
void openmm_vec3array_set_(OpenMM_Vec3Array* const& array, const int& index, const OpenMM_Vec3& vec) {
OpenMM_Vec3Array_set(array, index-1, vec);
}
void OPENMM_VEC3ARRAY_SET(OpenMM_Vec3Array* const& array, const int& index, const OpenMM_Vec3& vec) {
OpenMM_Vec3Array_set(array, index-1, vec);
}
void openmm_vec3array_get_(const OpenMM_Vec3Array* const& array, const int& index, OpenMM_Vec3& result) {
result = *OpenMM_Vec3Array_get(array, index-1);
}
void OPENMM_VEC3ARRAY_GET(const OpenMM_Vec3Array* const& array, const int& index, OpenMM_Vec3& result) {
result = *OpenMM_Vec3Array_get(array, index-1);
}
/* OpenMM_StringArray */
void openmm_stringarray_create_(OpenMM_StringArray*& result, const int& size) {
result = OpenMM_StringArray_create(size);
}
void OPENMM_STRINGARRAY_CREATE(OpenMM_StringArray*& result, const int& size) {
result = OpenMM_StringArray_create(size);
}
void openmm_stringarray_destroy_(OpenMM_StringArray*& array) {
OpenMM_StringArray_destroy(array);
array = 0;
}
void OPENMM_STRINGARRAY_DESTROY(OpenMM_StringArray*& array) {
OpenMM_StringArray_destroy(array);
array = 0;
}
int openmm_stringarray_getsize_(const OpenMM_StringArray* const& array) {
return OpenMM_StringArray_getSize(array);
}
int OPENMM_STRINGARRAY_GETSIZE(const OpenMM_StringArray* const& array) {
return OpenMM_StringArray_getSize(array);
}
void openmm_stringarray_resize_(OpenMM_StringArray* const& array, const int& size) {
OpenMM_StringArray_resize(array, size);
}
void OPENMM_STRINGARRAY_RESIZE(OpenMM_StringArray* const& array, const int& size) {
OpenMM_StringArray_resize(array, size);
}
void openmm_stringarray_append_(OpenMM_StringArray* const& array, const char* str, int length) {
OpenMM_StringArray_append(array, string(str, length).c_str());
}
void OPENMM_STRINGARRAY_APPEND(OpenMM_StringArray* const& array, const char* str, int length) {
OpenMM_StringArray_append(array, string(str, length).c_str());
}
void openmm_stringarray_set_(OpenMM_StringArray* const& array, const int& index, const char* str, int length) {
OpenMM_StringArray_set(array, index-1, string(str, length).c_str());
}
void OPENMM_STRINGARRAY_SET(OpenMM_StringArray* const& array, const int& index, const char* str, int length) {
OpenMM_StringArray_set(array, index-1, string(str, length).c_str());
}
void openmm_stringarray_get_(const OpenMM_StringArray* const& array, const int& index, char* result, int length) {
const char* str = OpenMM_StringArray_get(array, index-1);
strncpy(result, str, length);
}
void OPENMM_STRINGARRAY_GET(const OpenMM_StringArray* const& array, const int& index, char* result, int length) {
const char* str = OpenMM_StringArray_get(array, index-1);
strncpy(result, str, length);
}
/* OpenMM_BondArray */
void openmm_bondarray_create_(OpenMM_BondArray*& result, const int& size) {
result = OpenMM_BondArray_create(size);
}
void OPENMM_BONDARRAY_CREATE(OpenMM_BondArray*& result, const int& size) {
result = OpenMM_BondArray_create(size);
}
void openmm_bondarray_destroy_(OpenMM_BondArray*& array) {
OpenMM_BondArray_destroy(array);
array = 0;
}
void OPENMM_BONDARRAY_DESTROY(OpenMM_BondArray*& array) {
OpenMM_BondArray_destroy(array);
array = 0;
}
int openmm_bondarray_getsize_(const OpenMM_BondArray* const& array) {
return OpenMM_BondArray_getSize(array);
}
int OPENMM_BONDARRAY_GETSIZE(const OpenMM_BondArray* const& array) {
return OpenMM_BondArray_getSize(array);
}
void openmm_bondarray_resize_(OpenMM_BondArray* const& array, const int& size) {
OpenMM_BondArray_resize(array, size);
}
void OPENMM_BONDARRAY_RESIZE(OpenMM_BondArray* const& array, const int& size) {
OpenMM_BondArray_resize(array, size);
}
void openmm_bondarray_append_(OpenMM_BondArray* const& array, const int& particle1, const int& particle2) {
OpenMM_BondArray_append(array, particle1, particle2);
}
void OPENMM_BONDARRAY_APPEND(OpenMM_BondArray* const& array, const int& particle1, const int& particle2) {
OpenMM_BondArray_append(array, particle1, particle2);
}
void openmm_bondarray_set_(OpenMM_BondArray* const& array, const int& index, const int& particle1, const int& particle2) {
OpenMM_BondArray_set(array, index-1, particle1, particle2);
}
void OPENMM_BONDARRAY_SET(OpenMM_BondArray* const& array, const int& index, const int& particle1, const int& particle2) {
OpenMM_BondArray_set(array, index-1, particle1, particle2);
}
void openmm_bondarray_get_(const OpenMM_BondArray* const& array, const int& index, int* particle1, int* particle2) {
OpenMM_BondArray_get(array, index-1, particle1, particle2);
}
void OPENMM_BONDARRAY_GET(const OpenMM_BondArray* const& array, const int& index, int* particle1, int* particle2) {
OpenMM_BondArray_get(array, index-1, particle1, particle2);
}
/* OpenMM_ParameterArray */
int openmm_parameterarray_getsize_(const OpenMM_ParameterArray* const& array) {
return OpenMM_ParameterArray_getSize(array);
}
int OPENMM_PARAMETERARRAY_GETSIZE(const OpenMM_ParameterArray* const& array) {
return OpenMM_ParameterArray_getSize(array);
}
double openmm_parameterarray_get_(const OpenMM_ParameterArray* const& array, const char* name, int length) {
return OpenMM_ParameterArray_get(array, string(name, length).c_str());
}
double OPENMM_PARAMETERARRAY_GET(const OpenMM_ParameterArray* const& array, const char* name, int length) {
return OpenMM_ParameterArray_get(array, string(name, length).c_str());
}
/* These methods need to be handled specially, since their C++ APIs cannot be directly translated to C.
Unlike the C++ versions, the return value is allocated on the heap, and you must delete it yourself. */
void openmm_context_getstate_(const OpenMM_Context*& target, int const& types, OpenMM_State*& result) {
result = OpenMM_Context_getState(target, types);
};
void OPENMM_CONTEXT_GETSTATE(const OpenMM_Context*& target, int const& types, OpenMM_State*& result) {
result = OpenMM_Context_getState(target, types);
};
void openmm_platform_loadpluginsfromdirectory_(const char* directory, OpenMM_StringArray*& result, int length) {
result = OpenMM_Platform_loadPluginsFromDirectory(string(directory, length).c_str());
};
void OPENMM_PLATFORM_LOADPLUGINSFROMDIRECTORY(const char* directory, OpenMM_StringArray*& result, int length) {
result = OpenMM_Platform_loadPluginsFromDirectory(string(directory, length).c_str());
};
/* OpenMM::HarmonicBondForce*/
void openmm_harmonicbondforce_create_(OpenMM_HarmonicBondForce*& result) {
result = OpenMM_HarmonicBondForce_create();
}
void OPENMM_HARMONICBONDFORCE_CREATE(OpenMM_HarmonicBondForce*& result) {
result = OpenMM_HarmonicBondForce_create();
}
void openmm_harmonicbondforce_destroy_(OpenMM_HarmonicBondForce*& destroy) {
OpenMM_HarmonicBondForce_destroy(destroy);
destroy = 0;
}
void OPENMM_HARMONICBONDFORCE_DESTROY(OpenMM_HarmonicBondForce*& destroy) {
OpenMM_HarmonicBondForce_destroy(destroy);
destroy = 0;
}
int openmm_harmonicbondforce_getnumbonds_(const OpenMM_HarmonicBondForce*& target) {
return OpenMM_HarmonicBondForce_getNumBonds(target);
};
int OPENMM_HARMONICBONDFORCE_GETNUMBONDS(const OpenMM_HarmonicBondForce*& target) {
return OpenMM_HarmonicBondForce_getNumBonds(target);
};
int openmm_harmonicbondforce_addbond_(OpenMM_HarmonicBondForce*& target, int const& particle1, int const& particle2, double const& length, double const& k) {
return OpenMM_HarmonicBondForce_addBond(target, particle1, particle2, length, k);
};
int OPENMM_HARMONICBONDFORCE_ADDBOND(OpenMM_HarmonicBondForce*& target, int const& particle1, int const& particle2, double const& length, double const& k) {
return OpenMM_HarmonicBondForce_addBond(target, particle1, particle2, length, k);
};
void openmm_harmonicbondforce_getbondparameters_(const OpenMM_HarmonicBondForce*& target, int const& index, int* particle1, int* particle2, double* length, double* k) {
OpenMM_HarmonicBondForce_getBondParameters(target, index, particle1, particle2, length, k);
};
void OPENMM_HARMONICBONDFORCE_GETBONDPARAMETERS(const OpenMM_HarmonicBondForce*& target, int const& index, int* particle1, int* particle2, double* length, double* k) {
OpenMM_HarmonicBondForce_getBondParameters(target, index, particle1, particle2, length, k);
};
void openmm_harmonicbondforce_setbondparameters_(OpenMM_HarmonicBondForce*& target, int const& index, int const& particle1, int const& particle2, double const& length, double const& k) {
OpenMM_HarmonicBondForce_setBondParameters(target, index, particle1, particle2, length, k);
};
void OPENMM_HARMONICBONDFORCE_SETBONDPARAMETERS(OpenMM_HarmonicBondForce*& target, int const& index, int const& particle1, int const& particle2, double const& length, double const& k) {
OpenMM_HarmonicBondForce_setBondParameters(target, index, particle1, particle2, length, k);
};
/* OpenMM::BrownianIntegrator*/
void openmm_brownianintegrator_create_(OpenMM_BrownianIntegrator*& result, double const& temperature, double const& frictionCoeff, double const& stepSize) {
result = OpenMM_BrownianIntegrator_create(temperature, frictionCoeff, stepSize);
}
void OPENMM_BROWNIANINTEGRATOR_CREATE(OpenMM_BrownianIntegrator*& result, double const& temperature, double const& frictionCoeff, double const& stepSize) {
result = OpenMM_BrownianIntegrator_create(temperature, frictionCoeff, stepSize);
}
void openmm_brownianintegrator_destroy_(OpenMM_BrownianIntegrator*& destroy) {
OpenMM_BrownianIntegrator_destroy(destroy);
destroy = 0;
}
void OPENMM_BROWNIANINTEGRATOR_DESTROY(OpenMM_BrownianIntegrator*& destroy) {
OpenMM_BrownianIntegrator_destroy(destroy);
destroy = 0;
}
double openmm_brownianintegrator_gettemperature_(const OpenMM_BrownianIntegrator*& target) {
return OpenMM_BrownianIntegrator_getTemperature(target);
};
double OPENMM_BROWNIANINTEGRATOR_GETTEMPERATURE(const OpenMM_BrownianIntegrator*& target) {
return OpenMM_BrownianIntegrator_getTemperature(target);
};
void openmm_brownianintegrator_settemperature_(OpenMM_BrownianIntegrator*& target, double const& temp) {
OpenMM_BrownianIntegrator_setTemperature(target, temp);
};
void OPENMM_BROWNIANINTEGRATOR_SETTEMPERATURE(OpenMM_BrownianIntegrator*& target, double const& temp) {
OpenMM_BrownianIntegrator_setTemperature(target, temp);
};
double openmm_brownianintegrator_getfriction_(const OpenMM_BrownianIntegrator*& target) {
return OpenMM_BrownianIntegrator_getFriction(target);
};
double OPENMM_BROWNIANINTEGRATOR_GETFRICTION(const OpenMM_BrownianIntegrator*& target) {
return OpenMM_BrownianIntegrator_getFriction(target);
};
void openmm_brownianintegrator_setfriction_(OpenMM_BrownianIntegrator*& target, double const& coeff) {
OpenMM_BrownianIntegrator_setFriction(target, coeff);
};
void OPENMM_BROWNIANINTEGRATOR_SETFRICTION(OpenMM_BrownianIntegrator*& target, double const& coeff) {
OpenMM_BrownianIntegrator_setFriction(target, coeff);
};
int openmm_brownianintegrator_getrandomnumberseed_(const OpenMM_BrownianIntegrator*& target) {
return OpenMM_BrownianIntegrator_getRandomNumberSeed(target);
};
int OPENMM_BROWNIANINTEGRATOR_GETRANDOMNUMBERSEED(const OpenMM_BrownianIntegrator*& target) {
return OpenMM_BrownianIntegrator_getRandomNumberSeed(target);
};
void openmm_brownianintegrator_setrandomnumberseed_(OpenMM_BrownianIntegrator*& target, int const& seed) {
OpenMM_BrownianIntegrator_setRandomNumberSeed(target, seed);
};
void OPENMM_BROWNIANINTEGRATOR_SETRANDOMNUMBERSEED(OpenMM_BrownianIntegrator*& target, int const& seed) {
OpenMM_BrownianIntegrator_setRandomNumberSeed(target, seed);
};
void openmm_brownianintegrator_step_(OpenMM_BrownianIntegrator*& target, int const& steps) {
OpenMM_BrownianIntegrator_step(target, steps);
};
void OPENMM_BROWNIANINTEGRATOR_STEP(OpenMM_BrownianIntegrator*& target, int const& steps) {
OpenMM_BrownianIntegrator_step(target, steps);
};
/* OpenMM::OpenMMException*/
void openmm_openmmexception_create_(OpenMM_OpenMMException*& result, const char* message, int message_length) {
result = OpenMM_OpenMMException_create(string(message, message_length).c_str());
}
void OPENMM_OPENMMEXCEPTION_CREATE(OpenMM_OpenMMException*& result, const char* message, int message_length) {
result = OpenMM_OpenMMException_create(string(message, message_length).c_str());
}
void openmm_openmmexception_destroy_(OpenMM_OpenMMException*& destroy) {
OpenMM_OpenMMException_destroy(destroy);
destroy = 0;
}
void OPENMM_OPENMMEXCEPTION_DESTROY(OpenMM_OpenMMException*& destroy) {
OpenMM_OpenMMException_destroy(destroy);
destroy = 0;
}
void openmm_openmmexception_what_(const OpenMM_OpenMMException*& target, char* result, int result_length) {
const char* result_chars = OpenMM_OpenMMException_what(target);
strncpy(result, result_chars, result_length);
};
void OPENMM_OPENMMEXCEPTION_WHAT(const OpenMM_OpenMMException*& target, char* result, int result_length) {
const char* result_chars = OpenMM_OpenMMException_what(target);
strncpy(result, result_chars, result_length);
};
/* OpenMM::NonbondedForce*/
void openmm_nonbondedforce_create_(OpenMM_NonbondedForce*& result) {
result = OpenMM_NonbondedForce_create();
}
void OPENMM_NONBONDEDFORCE_CREATE(OpenMM_NonbondedForce*& result) {
result = OpenMM_NonbondedForce_create();
}
void openmm_nonbondedforce_destroy_(OpenMM_NonbondedForce*& destroy) {
OpenMM_NonbondedForce_destroy(destroy);
destroy = 0;
}
void OPENMM_NONBONDEDFORCE_DESTROY(OpenMM_NonbondedForce*& destroy) {
OpenMM_NonbondedForce_destroy(destroy);
destroy = 0;
}
int openmm_nonbondedforce_getnumparticles_(const OpenMM_NonbondedForce*& target) {
return OpenMM_NonbondedForce_getNumParticles(target);
};
int OPENMM_NONBONDEDFORCE_GETNUMPARTICLES(const OpenMM_NonbondedForce*& target) {
return OpenMM_NonbondedForce_getNumParticles(target);
};
int openmm_nonbondedforce_getnumexceptions_(const OpenMM_NonbondedForce*& target) {
return OpenMM_NonbondedForce_getNumExceptions(target);
};
int OPENMM_NONBONDEDFORCE_GETNUMEXCEPTIONS(const OpenMM_NonbondedForce*& target) {
return OpenMM_NonbondedForce_getNumExceptions(target);
};
void openmm_nonbondedforce_getnonbondedmethod_(const OpenMM_NonbondedForce*& target, int& result) {
result = OpenMM_NonbondedForce_getNonbondedMethod(target);
};
void OPENMM_NONBONDEDFORCE_GETNONBONDEDMETHOD(const OpenMM_NonbondedForce*& target, int& result) {
result = OpenMM_NonbondedForce_getNonbondedMethod(target);
};
void openmm_nonbondedforce_setnonbondedmethod_(OpenMM_NonbondedForce*& target, int const& method) {
OpenMM_NonbondedForce_setNonbondedMethod(target, (OpenMM_NonbondedForce_NonbondedMethod) method);
};
void OPENMM_NONBONDEDFORCE_SETNONBONDEDMETHOD(OpenMM_NonbondedForce*& target, int const& method) {
OpenMM_NonbondedForce_setNonbondedMethod(target, (OpenMM_NonbondedForce_NonbondedMethod) method);
};
double openmm_nonbondedforce_getcutoffdistance_(const OpenMM_NonbondedForce*& target) {
return OpenMM_NonbondedForce_getCutoffDistance(target);
};
double OPENMM_NONBONDEDFORCE_GETCUTOFFDISTANCE(const OpenMM_NonbondedForce*& target) {
return OpenMM_NonbondedForce_getCutoffDistance(target);
};
void openmm_nonbondedforce_setcutoffdistance_(OpenMM_NonbondedForce*& target, double const& distance) {
OpenMM_NonbondedForce_setCutoffDistance(target, distance);
};
void OPENMM_NONBONDEDFORCE_SETCUTOFFDISTANCE(OpenMM_NonbondedForce*& target, double const& distance) {
OpenMM_NonbondedForce_setCutoffDistance(target, distance);
};
double openmm_nonbondedforce_getreactionfielddielectric_(const OpenMM_NonbondedForce*& target) {
return OpenMM_NonbondedForce_getReactionFieldDielectric(target);
};
double OPENMM_NONBONDEDFORCE_GETREACTIONFIELDDIELECTRIC(const OpenMM_NonbondedForce*& target) {
return OpenMM_NonbondedForce_getReactionFieldDielectric(target);
};
void openmm_nonbondedforce_setreactionfielddielectric_(OpenMM_NonbondedForce*& target, double const& dielectric) {
OpenMM_NonbondedForce_setReactionFieldDielectric(target, dielectric);
};
void OPENMM_NONBONDEDFORCE_SETREACTIONFIELDDIELECTRIC(OpenMM_NonbondedForce*& target, double const& dielectric) {
OpenMM_NonbondedForce_setReactionFieldDielectric(target, dielectric);
};
double openmm_nonbondedforce_getewalderrortolerance_(const OpenMM_NonbondedForce*& target) {
return OpenMM_NonbondedForce_getEwaldErrorTolerance(target);
};
double OPENMM_NONBONDEDFORCE_GETEWALDERRORTOLERANCE(const OpenMM_NonbondedForce*& target) {
return OpenMM_NonbondedForce_getEwaldErrorTolerance(target);
};
void openmm_nonbondedforce_setewalderrortolerance_(OpenMM_NonbondedForce*& target, double const& tol) {
OpenMM_NonbondedForce_setEwaldErrorTolerance(target, tol);
};
void OPENMM_NONBONDEDFORCE_SETEWALDERRORTOLERANCE(OpenMM_NonbondedForce*& target, double const& tol) {
OpenMM_NonbondedForce_setEwaldErrorTolerance(target, tol);
};
void openmm_nonbondedforce_getperiodicboxvectors_(const OpenMM_NonbondedForce*& target, OpenMM_Vec3* a, OpenMM_Vec3* b, OpenMM_Vec3* c) {
OpenMM_NonbondedForce_getPeriodicBoxVectors(target, a, b, c);
};
void OPENMM_NONBONDEDFORCE_GETPERIODICBOXVECTORS(const OpenMM_NonbondedForce*& target, OpenMM_Vec3* a, OpenMM_Vec3* b, OpenMM_Vec3* c) {
OpenMM_NonbondedForce_getPeriodicBoxVectors(target, a, b, c);
};
void openmm_nonbondedforce_setperiodicboxvectors_(OpenMM_NonbondedForce*& target, OpenMM_Vec3 const& a, OpenMM_Vec3 const& b, OpenMM_Vec3 const& c) {
OpenMM_NonbondedForce_setPeriodicBoxVectors(target, a, b, c);
};
void OPENMM_NONBONDEDFORCE_SETPERIODICBOXVECTORS(OpenMM_NonbondedForce*& target, OpenMM_Vec3 const& a, OpenMM_Vec3 const& b, OpenMM_Vec3 const& c) {
OpenMM_NonbondedForce_setPeriodicBoxVectors(target, a, b, c);
};
int openmm_nonbondedforce_addparticle_(OpenMM_NonbondedForce*& target, double const& charge, double const& sigma, double const& epsilon) {
return OpenMM_NonbondedForce_addParticle(target, charge, sigma, epsilon);
};
int OPENMM_NONBONDEDFORCE_ADDPARTICLE(OpenMM_NonbondedForce*& target, double const& charge, double const& sigma, double const& epsilon) {
return OpenMM_NonbondedForce_addParticle(target, charge, sigma, epsilon);
};
void openmm_nonbondedforce_getparticleparameters_(const OpenMM_NonbondedForce*& target, int const& index, double* charge, double* sigma, double* epsilon) {
OpenMM_NonbondedForce_getParticleParameters(target, index, charge, sigma, epsilon);
};
void OPENMM_NONBONDEDFORCE_GETPARTICLEPARAMETERS(const OpenMM_NonbondedForce*& target, int const& index, double* charge, double* sigma, double* epsilon) {
OpenMM_NonbondedForce_getParticleParameters(target, index, charge, sigma, epsilon);
};
void openmm_nonbondedforce_setparticleparameters_(OpenMM_NonbondedForce*& target, int const& index, double const& charge, double const& sigma, double const& epsilon) {
OpenMM_NonbondedForce_setParticleParameters(target, index, charge, sigma, epsilon);
};
void OPENMM_NONBONDEDFORCE_SETPARTICLEPARAMETERS(OpenMM_NonbondedForce*& target, int const& index, double const& charge, double const& sigma, double const& epsilon) {
OpenMM_NonbondedForce_setParticleParameters(target, index, charge, sigma, epsilon);
};
int openmm_nonbondedforce_addexception_(OpenMM_NonbondedForce*& target, int const& particle1, int const& particle2, double const& chargeProd, double const& sigma, double const& epsilon, OpenMM_Boolean const& replace) {
return OpenMM_NonbondedForce_addException(target, particle1, particle2, chargeProd, sigma, epsilon, replace);
};
int OPENMM_NONBONDEDFORCE_ADDEXCEPTION(OpenMM_NonbondedForce*& target, int const& particle1, int const& particle2, double const& chargeProd, double const& sigma, double const& epsilon, OpenMM_Boolean const& replace) {
return OpenMM_NonbondedForce_addException(target, particle1, particle2, chargeProd, sigma, epsilon, replace);
};
void openmm_nonbondedforce_getexceptionparameters_(const OpenMM_NonbondedForce*& target, int const& index, int* particle1, int* particle2, double* chargeProd, double* sigma, double* epsilon) {
OpenMM_NonbondedForce_getExceptionParameters(target, index, particle1, particle2, chargeProd, sigma, epsilon);
};
void OPENMM_NONBONDEDFORCE_GETEXCEPTIONPARAMETERS(const OpenMM_NonbondedForce*& target, int const& index, int* particle1, int* particle2, double* chargeProd, double* sigma, double* epsilon) {
OpenMM_NonbondedForce_getExceptionParameters(target, index, particle1, particle2, chargeProd, sigma, epsilon);
};
void openmm_nonbondedforce_setexceptionparameters_(OpenMM_NonbondedForce*& target, int const& index, int const& particle1, int const& particle2, double const& chargeProd, double const& sigma, double const& epsilon) {
OpenMM_NonbondedForce_setExceptionParameters(target, index, particle1, particle2, chargeProd, sigma, epsilon);
};
void OPENMM_NONBONDEDFORCE_SETEXCEPTIONPARAMETERS(OpenMM_NonbondedForce*& target, int const& index, int const& particle1, int const& particle2, double const& chargeProd, double const& sigma, double const& epsilon) {
OpenMM_NonbondedForce_setExceptionParameters(target, index, particle1, particle2, chargeProd, sigma, epsilon);
};
void openmm_nonbondedforce_createexceptionsfrombonds_(OpenMM_NonbondedForce*& target, const OpenMM_BondArray*& bonds, double const& coulomb14Scale, double const& lj14Scale) {
OpenMM_NonbondedForce_createExceptionsFromBonds(target, bonds, coulomb14Scale, lj14Scale);
};
void OPENMM_NONBONDEDFORCE_CREATEEXCEPTIONSFROMBONDS(OpenMM_NonbondedForce*& target, const OpenMM_BondArray*& bonds, double const& coulomb14Scale, double const& lj14Scale) {
OpenMM_NonbondedForce_createExceptionsFromBonds(target, bonds, coulomb14Scale, lj14Scale);
};
/* OpenMM::VariableLangevinIntegrator*/
void openmm_variablelangevinintegrator_create_(OpenMM_VariableLangevinIntegrator*& result, double const& temperature, double const& frictionCoeff, double const& errorTol) {
result = OpenMM_VariableLangevinIntegrator_create(temperature, frictionCoeff, errorTol);
}
void OPENMM_VARIABLELANGEVININTEGRATOR_CREATE(OpenMM_VariableLangevinIntegrator*& result, double const& temperature, double const& frictionCoeff, double const& errorTol) {
result = OpenMM_VariableLangevinIntegrator_create(temperature, frictionCoeff, errorTol);
}
void openmm_variablelangevinintegrator_destroy_(OpenMM_VariableLangevinIntegrator*& destroy) {
OpenMM_VariableLangevinIntegrator_destroy(destroy);
destroy = 0;
}
void OPENMM_VARIABLELANGEVININTEGRATOR_DESTROY(OpenMM_VariableLangevinIntegrator*& destroy) {
OpenMM_VariableLangevinIntegrator_destroy(destroy);
destroy = 0;
}
double openmm_variablelangevinintegrator_gettemperature_(const OpenMM_VariableLangevinIntegrator*& target) {
return OpenMM_VariableLangevinIntegrator_getTemperature(target);
};
double OPENMM_VARIABLELANGEVININTEGRATOR_GETTEMPERATURE(const OpenMM_VariableLangevinIntegrator*& target) {
return OpenMM_VariableLangevinIntegrator_getTemperature(target);
};
void openmm_variablelangevinintegrator_settemperature_(OpenMM_VariableLangevinIntegrator*& target, double const& temp) {
OpenMM_VariableLangevinIntegrator_setTemperature(target, temp);
};
void OPENMM_VARIABLELANGEVININTEGRATOR_SETTEMPERATURE(OpenMM_VariableLangevinIntegrator*& target, double const& temp) {
OpenMM_VariableLangevinIntegrator_setTemperature(target, temp);
};
double openmm_variablelangevinintegrator_getfriction_(const OpenMM_VariableLangevinIntegrator*& target) {
return OpenMM_VariableLangevinIntegrator_getFriction(target);
};
double OPENMM_VARIABLELANGEVININTEGRATOR_GETFRICTION(const OpenMM_VariableLangevinIntegrator*& target) {
return OpenMM_VariableLangevinIntegrator_getFriction(target);
};
void openmm_variablelangevinintegrator_setfriction_(OpenMM_VariableLangevinIntegrator*& target, double const& coeff) {
OpenMM_VariableLangevinIntegrator_setFriction(target, coeff);
};
void OPENMM_VARIABLELANGEVININTEGRATOR_SETFRICTION(OpenMM_VariableLangevinIntegrator*& target, double const& coeff) {
OpenMM_VariableLangevinIntegrator_setFriction(target, coeff);
};
double openmm_variablelangevinintegrator_geterrortolerance_(const OpenMM_VariableLangevinIntegrator*& target) {
return OpenMM_VariableLangevinIntegrator_getErrorTolerance(target);
};
double OPENMM_VARIABLELANGEVININTEGRATOR_GETERRORTOLERANCE(const OpenMM_VariableLangevinIntegrator*& target) {
return OpenMM_VariableLangevinIntegrator_getErrorTolerance(target);
};
void openmm_variablelangevinintegrator_seterrortolerance_(OpenMM_VariableLangevinIntegrator*& target, double const& tol) {
OpenMM_VariableLangevinIntegrator_setErrorTolerance(target, tol);
};
void OPENMM_VARIABLELANGEVININTEGRATOR_SETERRORTOLERANCE(OpenMM_VariableLangevinIntegrator*& target, double const& tol) {
OpenMM_VariableLangevinIntegrator_setErrorTolerance(target, tol);
};
int openmm_variablelangevinintegrator_getrandomnumberseed_(const OpenMM_VariableLangevinIntegrator*& target) {
return OpenMM_VariableLangevinIntegrator_getRandomNumberSeed(target);
};
int OPENMM_VARIABLELANGEVININTEGRATOR_GETRANDOMNUMBERSEED(const OpenMM_VariableLangevinIntegrator*& target) {
return OpenMM_VariableLangevinIntegrator_getRandomNumberSeed(target);
};
void openmm_variablelangevinintegrator_setrandomnumberseed_(OpenMM_VariableLangevinIntegrator*& target, int const& seed) {
OpenMM_VariableLangevinIntegrator_setRandomNumberSeed(target, seed);
};
void OPENMM_VARIABLELANGEVININTEGRATOR_SETRANDOMNUMBERSEED(OpenMM_VariableLangevinIntegrator*& target, int const& seed) {
OpenMM_VariableLangevinIntegrator_setRandomNumberSeed(target, seed);
};
void openmm_variablelangevinintegrator_step_(OpenMM_VariableLangevinIntegrator*& target, int const& steps) {
OpenMM_VariableLangevinIntegrator_step(target, steps);
};
void OPENMM_VARIABLELANGEVININTEGRATOR_STEP(OpenMM_VariableLangevinIntegrator*& target, int const& steps) {
OpenMM_VariableLangevinIntegrator_step(target, steps);
};
void openmm_variablelangevinintegrator_stepto_(OpenMM_VariableLangevinIntegrator*& target, double const& time) {
OpenMM_VariableLangevinIntegrator_stepTo(target, time);
};
void OPENMM_VARIABLELANGEVININTEGRATOR_STEPTO(OpenMM_VariableLangevinIntegrator*& target, double const& time) {
OpenMM_VariableLangevinIntegrator_stepTo(target, time);
};
/* OpenMM::GBVIForce*/
void openmm_gbviforce_create_(OpenMM_GBVIForce*& result) {
result = OpenMM_GBVIForce_create();
}
void OPENMM_GBVIFORCE_CREATE(OpenMM_GBVIForce*& result) {
result = OpenMM_GBVIForce_create();
}
void openmm_gbviforce_destroy_(OpenMM_GBVIForce*& destroy) {
OpenMM_GBVIForce_destroy(destroy);
destroy = 0;
}
void OPENMM_GBVIFORCE_DESTROY(OpenMM_GBVIForce*& destroy) {
OpenMM_GBVIForce_destroy(destroy);
destroy = 0;
}
int openmm_gbviforce_getnumparticles_(const OpenMM_GBVIForce*& target) {
return OpenMM_GBVIForce_getNumParticles(target);
};
int OPENMM_GBVIFORCE_GETNUMPARTICLES(const OpenMM_GBVIForce*& target) {
return OpenMM_GBVIForce_getNumParticles(target);
};
int openmm_gbviforce_addparticle_(OpenMM_GBVIForce*& target, double const& charge, double const& radius, double const& gamma) {
return OpenMM_GBVIForce_addParticle(target, charge, radius, gamma);
};
int OPENMM_GBVIFORCE_ADDPARTICLE(OpenMM_GBVIForce*& target, double const& charge, double const& radius, double const& gamma) {
return OpenMM_GBVIForce_addParticle(target, charge, radius, gamma);
};
void openmm_gbviforce_getparticleparameters_(const OpenMM_GBVIForce*& target, int const& index, double* charge, double* radius, double* gamma) {
OpenMM_GBVIForce_getParticleParameters(target, index, charge, radius, gamma);
};
void OPENMM_GBVIFORCE_GETPARTICLEPARAMETERS(const OpenMM_GBVIForce*& target, int const& index, double* charge, double* radius, double* gamma) {
OpenMM_GBVIForce_getParticleParameters(target, index, charge, radius, gamma);
};
void openmm_gbviforce_setparticleparameters_(OpenMM_GBVIForce*& target, int const& index, double const& charge, double const& radius, double const& gamma) {
OpenMM_GBVIForce_setParticleParameters(target, index, charge, radius, gamma);
};
void OPENMM_GBVIFORCE_SETPARTICLEPARAMETERS(OpenMM_GBVIForce*& target, int const& index, double const& charge, double const& radius, double const& gamma) {
OpenMM_GBVIForce_setParticleParameters(target, index, charge, radius, gamma);
};
double openmm_gbviforce_getsolventdielectric_(const OpenMM_GBVIForce*& target) {
return OpenMM_GBVIForce_getSolventDielectric(target);
};
double OPENMM_GBVIFORCE_GETSOLVENTDIELECTRIC(const OpenMM_GBVIForce*& target) {
return OpenMM_GBVIForce_getSolventDielectric(target);
};
void openmm_gbviforce_setsolventdielectric_(OpenMM_GBVIForce*& target, double const& dielectric) {
OpenMM_GBVIForce_setSolventDielectric(target, dielectric);
};
void OPENMM_GBVIFORCE_SETSOLVENTDIELECTRIC(OpenMM_GBVIForce*& target, double const& dielectric) {
OpenMM_GBVIForce_setSolventDielectric(target, dielectric);
};
double openmm_gbviforce_getsolutedielectric_(const OpenMM_GBVIForce*& target) {
return OpenMM_GBVIForce_getSoluteDielectric(target);
};
double OPENMM_GBVIFORCE_GETSOLUTEDIELECTRIC(const OpenMM_GBVIForce*& target) {
return OpenMM_GBVIForce_getSoluteDielectric(target);
};
void openmm_gbviforce_setsolutedielectric_(OpenMM_GBVIForce*& target, double const& dielectric) {
OpenMM_GBVIForce_setSoluteDielectric(target, dielectric);
};
void OPENMM_GBVIFORCE_SETSOLUTEDIELECTRIC(OpenMM_GBVIForce*& target, double const& dielectric) {
OpenMM_GBVIForce_setSoluteDielectric(target, dielectric);
};
/* OpenMM::Context*/
void openmm_context_create_(OpenMM_Context*& result, OpenMM_System*& system, OpenMM_Integrator*& integrator) {
result = OpenMM_Context_create(system, integrator);
}
void OPENMM_CONTEXT_CREATE(OpenMM_Context*& result, OpenMM_System*& system, OpenMM_Integrator*& integrator) {
result = OpenMM_Context_create(system, integrator);
}
void openmm_context_create_2_(OpenMM_Context*& result, OpenMM_System*& system, OpenMM_Integrator*& integrator, OpenMM_Platform*& platform) {
result = OpenMM_Context_create_2(system, integrator, platform);
}
void OPENMM_CONTEXT_CREATE_2(OpenMM_Context*& result, OpenMM_System*& system, OpenMM_Integrator*& integrator, OpenMM_Platform*& platform) {
result = OpenMM_Context_create_2(system, integrator, platform);
}
void openmm_context_destroy_(OpenMM_Context*& destroy) {
OpenMM_Context_destroy(destroy);
destroy = 0;
}
void OPENMM_CONTEXT_DESTROY(OpenMM_Context*& destroy) {
OpenMM_Context_destroy(destroy);
destroy = 0;
}
void openmm_context_getsystem_(OpenMM_Context*& target, OpenMM_System*& result) {
result = OpenMM_Context_getSystem(target);
};
void OPENMM_CONTEXT_GETSYSTEM(OpenMM_Context*& target, OpenMM_System*& result) {
result = OpenMM_Context_getSystem(target);
};
void openmm_context_getintegrator_(OpenMM_Context*& target, OpenMM_Integrator*& result) {
result = OpenMM_Context_getIntegrator(target);
};
void OPENMM_CONTEXT_GETINTEGRATOR(OpenMM_Context*& target, OpenMM_Integrator*& result) {
result = OpenMM_Context_getIntegrator(target);
};
void openmm_context_getplatform_(OpenMM_Context*& target, OpenMM_Platform*& result) {
result = OpenMM_Context_getPlatform(target);
};
void OPENMM_CONTEXT_GETPLATFORM(OpenMM_Context*& target, OpenMM_Platform*& result) {
result = OpenMM_Context_getPlatform(target);
};
void openmm_context_settime_(OpenMM_Context*& target, double const& time) {
OpenMM_Context_setTime(target, time);
};
void OPENMM_CONTEXT_SETTIME(OpenMM_Context*& target, double const& time) {
OpenMM_Context_setTime(target, time);
};
void openmm_context_setpositions_(OpenMM_Context*& target, const OpenMM_Vec3Array*& positions) {
OpenMM_Context_setPositions(target, positions);
};
void OPENMM_CONTEXT_SETPOSITIONS(OpenMM_Context*& target, const OpenMM_Vec3Array*& positions) {
OpenMM_Context_setPositions(target, positions);
};
void openmm_context_setvelocities_(OpenMM_Context*& target, const OpenMM_Vec3Array*& velocities) {
OpenMM_Context_setVelocities(target, velocities);
};
void OPENMM_CONTEXT_SETVELOCITIES(OpenMM_Context*& target, const OpenMM_Vec3Array*& velocities) {
OpenMM_Context_setVelocities(target, velocities);
};
double openmm_context_getparameter_(OpenMM_Context*& target, const char* name, int name_length) {
return OpenMM_Context_getParameter(target, string(name, name_length).c_str());
};
double OPENMM_CONTEXT_GETPARAMETER(OpenMM_Context*& target, const char* name, int name_length) {
return OpenMM_Context_getParameter(target, string(name, name_length).c_str());
};
void openmm_context_setparameter_(OpenMM_Context*& target, const char* name, double const& value, int name_length) {
OpenMM_Context_setParameter(target, string(name, name_length).c_str(), value);
};
void OPENMM_CONTEXT_SETPARAMETER(OpenMM_Context*& target, const char* name, double const& value, int name_length) {
OpenMM_Context_setParameter(target, string(name, name_length).c_str(), value);
};
void openmm_context_reinitialize_(OpenMM_Context*& target) {
OpenMM_Context_reinitialize(target);
};
void OPENMM_CONTEXT_REINITIALIZE(OpenMM_Context*& target) {
OpenMM_Context_reinitialize(target);
};
/* OpenMM::GBSAOBCForce*/
void openmm_gbsaobcforce_create_(OpenMM_GBSAOBCForce*& result) {
result = OpenMM_GBSAOBCForce_create();
}
void OPENMM_GBSAOBCFORCE_CREATE(OpenMM_GBSAOBCForce*& result) {
result = OpenMM_GBSAOBCForce_create();
}
void openmm_gbsaobcforce_destroy_(OpenMM_GBSAOBCForce*& destroy) {
OpenMM_GBSAOBCForce_destroy(destroy);
destroy = 0;
}
void OPENMM_GBSAOBCFORCE_DESTROY(OpenMM_GBSAOBCForce*& destroy) {
OpenMM_GBSAOBCForce_destroy(destroy);
destroy = 0;
}
int openmm_gbsaobcforce_getnumparticles_(const OpenMM_GBSAOBCForce*& target) {
return OpenMM_GBSAOBCForce_getNumParticles(target);
};
int OPENMM_GBSAOBCFORCE_GETNUMPARTICLES(const OpenMM_GBSAOBCForce*& target) {
return OpenMM_GBSAOBCForce_getNumParticles(target);
};
int openmm_gbsaobcforce_addparticle_(OpenMM_GBSAOBCForce*& target, double const& charge, double const& radius, double const& scalingFactor) {
return OpenMM_GBSAOBCForce_addParticle(target, charge, radius, scalingFactor);
};
int OPENMM_GBSAOBCFORCE_ADDPARTICLE(OpenMM_GBSAOBCForce*& target, double const& charge, double const& radius, double const& scalingFactor) {
return OpenMM_GBSAOBCForce_addParticle(target, charge, radius, scalingFactor);
};
void openmm_gbsaobcforce_getparticleparameters_(const OpenMM_GBSAOBCForce*& target, int const& index, double* charge, double* radius, double* scalingFactor) {
OpenMM_GBSAOBCForce_getParticleParameters(target, index, charge, radius, scalingFactor);
};
void OPENMM_GBSAOBCFORCE_GETPARTICLEPARAMETERS(const OpenMM_GBSAOBCForce*& target, int const& index, double* charge, double* radius, double* scalingFactor) {
OpenMM_GBSAOBCForce_getParticleParameters(target, index, charge, radius, scalingFactor);
};
void openmm_gbsaobcforce_setparticleparameters_(OpenMM_GBSAOBCForce*& target, int const& index, double const& charge, double const& radius, double const& scalingFactor) {
OpenMM_GBSAOBCForce_setParticleParameters(target, index, charge, radius, scalingFactor);
};
void OPENMM_GBSAOBCFORCE_SETPARTICLEPARAMETERS(OpenMM_GBSAOBCForce*& target, int const& index, double const& charge, double const& radius, double const& scalingFactor) {
OpenMM_GBSAOBCForce_setParticleParameters(target, index, charge, radius, scalingFactor);
};
double openmm_gbsaobcforce_getsolventdielectric_(const OpenMM_GBSAOBCForce*& target) {
return OpenMM_GBSAOBCForce_getSolventDielectric(target);
};
double OPENMM_GBSAOBCFORCE_GETSOLVENTDIELECTRIC(const OpenMM_GBSAOBCForce*& target) {
return OpenMM_GBSAOBCForce_getSolventDielectric(target);
};
void openmm_gbsaobcforce_setsolventdielectric_(OpenMM_GBSAOBCForce*& target, double const& dielectric) {
OpenMM_GBSAOBCForce_setSolventDielectric(target, dielectric);
};
void OPENMM_GBSAOBCFORCE_SETSOLVENTDIELECTRIC(OpenMM_GBSAOBCForce*& target, double const& dielectric) {
OpenMM_GBSAOBCForce_setSolventDielectric(target, dielectric);
};
double openmm_gbsaobcforce_getsolutedielectric_(const OpenMM_GBSAOBCForce*& target) {
return OpenMM_GBSAOBCForce_getSoluteDielectric(target);
};
double OPENMM_GBSAOBCFORCE_GETSOLUTEDIELECTRIC(const OpenMM_GBSAOBCForce*& target) {
return OpenMM_GBSAOBCForce_getSoluteDielectric(target);
};
void openmm_gbsaobcforce_setsolutedielectric_(OpenMM_GBSAOBCForce*& target, double const& dielectric) {
OpenMM_GBSAOBCForce_setSoluteDielectric(target, dielectric);
};
void OPENMM_GBSAOBCFORCE_SETSOLUTEDIELECTRIC(OpenMM_GBSAOBCForce*& target, double const& dielectric) {
OpenMM_GBSAOBCForce_setSoluteDielectric(target, dielectric);
};
/* OpenMM::VariableVerletIntegrator*/
void openmm_variableverletintegrator_create_(OpenMM_VariableVerletIntegrator*& result, double const& errorTol) {
result = OpenMM_VariableVerletIntegrator_create(errorTol);
}
void OPENMM_VARIABLEVERLETINTEGRATOR_CREATE(OpenMM_VariableVerletIntegrator*& result, double const& errorTol) {
result = OpenMM_VariableVerletIntegrator_create(errorTol);
}
void openmm_variableverletintegrator_destroy_(OpenMM_VariableVerletIntegrator*& destroy) {
OpenMM_VariableVerletIntegrator_destroy(destroy);
destroy = 0;
}
void OPENMM_VARIABLEVERLETINTEGRATOR_DESTROY(OpenMM_VariableVerletIntegrator*& destroy) {
OpenMM_VariableVerletIntegrator_destroy(destroy);
destroy = 0;
}
double openmm_variableverletintegrator_geterrortolerance_(const OpenMM_VariableVerletIntegrator*& target) {
return OpenMM_VariableVerletIntegrator_getErrorTolerance(target);
};
double OPENMM_VARIABLEVERLETINTEGRATOR_GETERRORTOLERANCE(const OpenMM_VariableVerletIntegrator*& target) {
return OpenMM_VariableVerletIntegrator_getErrorTolerance(target);
};
void openmm_variableverletintegrator_seterrortolerance_(OpenMM_VariableVerletIntegrator*& target, double const& tol) {
OpenMM_VariableVerletIntegrator_setErrorTolerance(target, tol);
};
void OPENMM_VARIABLEVERLETINTEGRATOR_SETERRORTOLERANCE(OpenMM_VariableVerletIntegrator*& target, double const& tol) {
OpenMM_VariableVerletIntegrator_setErrorTolerance(target, tol);
};
void openmm_variableverletintegrator_step_(OpenMM_VariableVerletIntegrator*& target, int const& steps) {
OpenMM_VariableVerletIntegrator_step(target, steps);
};
void OPENMM_VARIABLEVERLETINTEGRATOR_STEP(OpenMM_VariableVerletIntegrator*& target, int const& steps) {
OpenMM_VariableVerletIntegrator_step(target, steps);
};
void openmm_variableverletintegrator_stepto_(OpenMM_VariableVerletIntegrator*& target, double const& time) {
OpenMM_VariableVerletIntegrator_stepTo(target, time);
};
void OPENMM_VARIABLEVERLETINTEGRATOR_STEPTO(OpenMM_VariableVerletIntegrator*& target, double const& time) {
OpenMM_VariableVerletIntegrator_stepTo(target, time);
};
/* OpenMM::CMMotionRemover*/
void openmm_cmmotionremover_create_(OpenMM_CMMotionRemover*& result, int const& frequency) {
result = OpenMM_CMMotionRemover_create(frequency);
}
void OPENMM_CMMOTIONREMOVER_CREATE(OpenMM_CMMotionRemover*& result, int const& frequency) {
result = OpenMM_CMMotionRemover_create(frequency);
}
void openmm_cmmotionremover_destroy_(OpenMM_CMMotionRemover*& destroy) {
OpenMM_CMMotionRemover_destroy(destroy);
destroy = 0;
}
void OPENMM_CMMOTIONREMOVER_DESTROY(OpenMM_CMMotionRemover*& destroy) {
OpenMM_CMMotionRemover_destroy(destroy);
destroy = 0;
}
int openmm_cmmotionremover_getfrequency_(const OpenMM_CMMotionRemover*& target) {
return OpenMM_CMMotionRemover_getFrequency(target);
};
int OPENMM_CMMOTIONREMOVER_GETFREQUENCY(const OpenMM_CMMotionRemover*& target) {
return OpenMM_CMMotionRemover_getFrequency(target);
};
void openmm_cmmotionremover_setfrequency_(OpenMM_CMMotionRemover*& target, int const& freq) {
OpenMM_CMMotionRemover_setFrequency(target, freq);
};
void OPENMM_CMMOTIONREMOVER_SETFREQUENCY(OpenMM_CMMotionRemover*& target, int const& freq) {
OpenMM_CMMotionRemover_setFrequency(target, freq);
};
/* OpenMM::VerletIntegrator*/
void openmm_verletintegrator_create_(OpenMM_VerletIntegrator*& result, double const& stepSize) {
result = OpenMM_VerletIntegrator_create(stepSize);
}
void OPENMM_VERLETINTEGRATOR_CREATE(OpenMM_VerletIntegrator*& result, double const& stepSize) {
result = OpenMM_VerletIntegrator_create(stepSize);
}
void openmm_verletintegrator_destroy_(OpenMM_VerletIntegrator*& destroy) {
OpenMM_VerletIntegrator_destroy(destroy);
destroy = 0;
}
void OPENMM_VERLETINTEGRATOR_DESTROY(OpenMM_VerletIntegrator*& destroy) {
OpenMM_VerletIntegrator_destroy(destroy);
destroy = 0;
}
void openmm_verletintegrator_step_(OpenMM_VerletIntegrator*& target, int const& steps) {
OpenMM_VerletIntegrator_step(target, steps);
};
void OPENMM_VERLETINTEGRATOR_STEP(OpenMM_VerletIntegrator*& target, int const& steps) {
OpenMM_VerletIntegrator_step(target, steps);
};
/* OpenMM::RBTorsionForce*/
void openmm_rbtorsionforce_create_(OpenMM_RBTorsionForce*& result) {
result = OpenMM_RBTorsionForce_create();
}
void OPENMM_RBTORSIONFORCE_CREATE(OpenMM_RBTorsionForce*& result) {
result = OpenMM_RBTorsionForce_create();
}
void openmm_rbtorsionforce_destroy_(OpenMM_RBTorsionForce*& destroy) {
OpenMM_RBTorsionForce_destroy(destroy);
destroy = 0;
}
void OPENMM_RBTORSIONFORCE_DESTROY(OpenMM_RBTorsionForce*& destroy) {
OpenMM_RBTorsionForce_destroy(destroy);
destroy = 0;
}
int openmm_rbtorsionforce_getnumtorsions_(const OpenMM_RBTorsionForce*& target) {
return OpenMM_RBTorsionForce_getNumTorsions(target);
};
int OPENMM_RBTORSIONFORCE_GETNUMTORSIONS(const OpenMM_RBTorsionForce*& target) {
return OpenMM_RBTorsionForce_getNumTorsions(target);
};
int openmm_rbtorsionforce_addtorsion_(OpenMM_RBTorsionForce*& target, int const& particle1, int const& particle2, int const& particle3, int const& particle4, double const& c0, double const& c1, double const& c2, double const& c3, double const& c4, double const& c5) {
return OpenMM_RBTorsionForce_addTorsion(target, particle1, particle2, particle3, particle4, c0, c1, c2, c3, c4, c5);
};
int OPENMM_RBTORSIONFORCE_ADDTORSION(OpenMM_RBTorsionForce*& target, int const& particle1, int const& particle2, int const& particle3, int const& particle4, double const& c0, double const& c1, double const& c2, double const& c3, double const& c4, double const& c5) {
return OpenMM_RBTorsionForce_addTorsion(target, particle1, particle2, particle3, particle4, c0, c1, c2, c3, c4, c5);
};
void openmm_rbtorsionforce_gettorsionparameters_(const OpenMM_RBTorsionForce*& target, int const& index, int* particle1, int* particle2, int* particle3, int* particle4, double* c0, double* c1, double* c2, double* c3, double* c4, double* c5) {
OpenMM_RBTorsionForce_getTorsionParameters(target, index, particle1, particle2, particle3, particle4, c0, c1, c2, c3, c4, c5);
};
void OPENMM_RBTORSIONFORCE_GETTORSIONPARAMETERS(const OpenMM_RBTorsionForce*& target, int const& index, int* particle1, int* particle2, int* particle3, int* particle4, double* c0, double* c1, double* c2, double* c3, double* c4, double* c5) {
OpenMM_RBTorsionForce_getTorsionParameters(target, index, particle1, particle2, particle3, particle4, c0, c1, c2, c3, c4, c5);
};
void openmm_rbtorsionforce_settorsionparameters_(OpenMM_RBTorsionForce*& target, int const& index, int const& particle1, int const& particle2, int const& particle3, int const& particle4, double const& c0, double const& c1, double const& c2, double const& c3, double const& c4, double const& c5) {
OpenMM_RBTorsionForce_setTorsionParameters(target, index, particle1, particle2, particle3, particle4, c0, c1, c2, c3, c4, c5);
};
void OPENMM_RBTORSIONFORCE_SETTORSIONPARAMETERS(OpenMM_RBTorsionForce*& target, int const& index, int const& particle1, int const& particle2, int const& particle3, int const& particle4, double const& c0, double const& c1, double const& c2, double const& c3, double const& c4, double const& c5) {
OpenMM_RBTorsionForce_setTorsionParameters(target, index, particle1, particle2, particle3, particle4, c0, c1, c2, c3, c4, c5);
};
/* OpenMM::LangevinIntegrator*/
void openmm_langevinintegrator_create_(OpenMM_LangevinIntegrator*& result, double const& temperature, double const& frictionCoeff, double const& stepSize) {
result = OpenMM_LangevinIntegrator_create(temperature, frictionCoeff, stepSize);
}
void OPENMM_LANGEVININTEGRATOR_CREATE(OpenMM_LangevinIntegrator*& result, double const& temperature, double const& frictionCoeff, double const& stepSize) {
result = OpenMM_LangevinIntegrator_create(temperature, frictionCoeff, stepSize);
}
void openmm_langevinintegrator_destroy_(OpenMM_LangevinIntegrator*& destroy) {
OpenMM_LangevinIntegrator_destroy(destroy);
destroy = 0;
}
void OPENMM_LANGEVININTEGRATOR_DESTROY(OpenMM_LangevinIntegrator*& destroy) {
OpenMM_LangevinIntegrator_destroy(destroy);
destroy = 0;
}
double openmm_langevinintegrator_gettemperature_(const OpenMM_LangevinIntegrator*& target) {
return OpenMM_LangevinIntegrator_getTemperature(target);
};
double OPENMM_LANGEVININTEGRATOR_GETTEMPERATURE(const OpenMM_LangevinIntegrator*& target) {
return OpenMM_LangevinIntegrator_getTemperature(target);
};
void openmm_langevinintegrator_settemperature_(OpenMM_LangevinIntegrator*& target, double const& temp) {
OpenMM_LangevinIntegrator_setTemperature(target, temp);
};
void OPENMM_LANGEVININTEGRATOR_SETTEMPERATURE(OpenMM_LangevinIntegrator*& target, double const& temp) {
OpenMM_LangevinIntegrator_setTemperature(target, temp);
};
double openmm_langevinintegrator_getfriction_(const OpenMM_LangevinIntegrator*& target) {
return OpenMM_LangevinIntegrator_getFriction(target);
};
double OPENMM_LANGEVININTEGRATOR_GETFRICTION(const OpenMM_LangevinIntegrator*& target) {
return OpenMM_LangevinIntegrator_getFriction(target);
};
void openmm_langevinintegrator_setfriction_(OpenMM_LangevinIntegrator*& target, double const& coeff) {
OpenMM_LangevinIntegrator_setFriction(target, coeff);
};
void OPENMM_LANGEVININTEGRATOR_SETFRICTION(OpenMM_LangevinIntegrator*& target, double const& coeff) {
OpenMM_LangevinIntegrator_setFriction(target, coeff);
};
int openmm_langevinintegrator_getrandomnumberseed_(const OpenMM_LangevinIntegrator*& target) {
return OpenMM_LangevinIntegrator_getRandomNumberSeed(target);
};
int OPENMM_LANGEVININTEGRATOR_GETRANDOMNUMBERSEED(const OpenMM_LangevinIntegrator*& target) {
return OpenMM_LangevinIntegrator_getRandomNumberSeed(target);
};
void openmm_langevinintegrator_setrandomnumberseed_(OpenMM_LangevinIntegrator*& target, int const& seed) {
OpenMM_LangevinIntegrator_setRandomNumberSeed(target, seed);
};
void OPENMM_LANGEVININTEGRATOR_SETRANDOMNUMBERSEED(OpenMM_LangevinIntegrator*& target, int const& seed) {
OpenMM_LangevinIntegrator_setRandomNumberSeed(target, seed);
};
void openmm_langevinintegrator_step_(OpenMM_LangevinIntegrator*& target, int const& steps) {
OpenMM_LangevinIntegrator_step(target, steps);
};
void OPENMM_LANGEVININTEGRATOR_STEP(OpenMM_LangevinIntegrator*& target, int const& steps) {
OpenMM_LangevinIntegrator_step(target, steps);
};
/* OpenMM::Force*/
void openmm_force_destroy_(OpenMM_Force*& destroy) {
OpenMM_Force_destroy(destroy);
destroy = 0;
}
void OPENMM_FORCE_DESTROY(OpenMM_Force*& destroy) {
OpenMM_Force_destroy(destroy);
destroy = 0;
}
/* OpenMM::HarmonicAngleForce*/
void openmm_harmonicangleforce_create_(OpenMM_HarmonicAngleForce*& result) {
result = OpenMM_HarmonicAngleForce_create();
}
void OPENMM_HARMONICANGLEFORCE_CREATE(OpenMM_HarmonicAngleForce*& result) {
result = OpenMM_HarmonicAngleForce_create();
}
void openmm_harmonicangleforce_destroy_(OpenMM_HarmonicAngleForce*& destroy) {
OpenMM_HarmonicAngleForce_destroy(destroy);
destroy = 0;
}
void OPENMM_HARMONICANGLEFORCE_DESTROY(OpenMM_HarmonicAngleForce*& destroy) {
OpenMM_HarmonicAngleForce_destroy(destroy);
destroy = 0;
}
int openmm_harmonicangleforce_getnumangles_(const OpenMM_HarmonicAngleForce*& target) {
return OpenMM_HarmonicAngleForce_getNumAngles(target);
};
int OPENMM_HARMONICANGLEFORCE_GETNUMANGLES(const OpenMM_HarmonicAngleForce*& target) {
return OpenMM_HarmonicAngleForce_getNumAngles(target);
};
int openmm_harmonicangleforce_addangle_(OpenMM_HarmonicAngleForce*& target, int const& particle1, int const& particle2, int const& particle3, double const& angle, double const& k) {
return OpenMM_HarmonicAngleForce_addAngle(target, particle1, particle2, particle3, angle, k);
};
int OPENMM_HARMONICANGLEFORCE_ADDANGLE(OpenMM_HarmonicAngleForce*& target, int const& particle1, int const& particle2, int const& particle3, double const& angle, double const& k) {
return OpenMM_HarmonicAngleForce_addAngle(target, particle1, particle2, particle3, angle, k);
};
void openmm_harmonicangleforce_getangleparameters_(const OpenMM_HarmonicAngleForce*& target, int const& index, int* particle1, int* particle2, int* particle3, double* angle, double* k) {
OpenMM_HarmonicAngleForce_getAngleParameters(target, index, particle1, particle2, particle3, angle, k);
};
void OPENMM_HARMONICANGLEFORCE_GETANGLEPARAMETERS(const OpenMM_HarmonicAngleForce*& target, int const& index, int* particle1, int* particle2, int* particle3, double* angle, double* k) {
OpenMM_HarmonicAngleForce_getAngleParameters(target, index, particle1, particle2, particle3, angle, k);
};
void openmm_harmonicangleforce_setangleparameters_(OpenMM_HarmonicAngleForce*& target, int const& index, int const& particle1, int const& particle2, int const& particle3, double const& angle, double const& k) {
OpenMM_HarmonicAngleForce_setAngleParameters(target, index, particle1, particle2, particle3, angle, k);
};
void OPENMM_HARMONICANGLEFORCE_SETANGLEPARAMETERS(OpenMM_HarmonicAngleForce*& target, int const& index, int const& particle1, int const& particle2, int const& particle3, double const& angle, double const& k) {
OpenMM_HarmonicAngleForce_setAngleParameters(target, index, particle1, particle2, particle3, angle, k);
};
/* OpenMM::AndersenThermostat*/
void openmm_andersenthermostat_create_(OpenMM_AndersenThermostat*& result, double const& defaultTemperature, double const& defaultCollisionFrequency) {
result = OpenMM_AndersenThermostat_create(defaultTemperature, defaultCollisionFrequency);
}
void OPENMM_ANDERSENTHERMOSTAT_CREATE(OpenMM_AndersenThermostat*& result, double const& defaultTemperature, double const& defaultCollisionFrequency) {
result = OpenMM_AndersenThermostat_create(defaultTemperature, defaultCollisionFrequency);
}
void openmm_andersenthermostat_destroy_(OpenMM_AndersenThermostat*& destroy) {
OpenMM_AndersenThermostat_destroy(destroy);
destroy = 0;
}
void OPENMM_ANDERSENTHERMOSTAT_DESTROY(OpenMM_AndersenThermostat*& destroy) {
OpenMM_AndersenThermostat_destroy(destroy);
destroy = 0;
}
void openmm_andersenthermostat_temperature_(char* result, int result_length) {
const char* result_chars = OpenMM_AndersenThermostat_Temperature();
strncpy(result, result_chars, result_length);
};
void OPENMM_ANDERSENTHERMOSTAT_TEMPERATURE(char* result, int result_length) {
const char* result_chars = OpenMM_AndersenThermostat_Temperature();
strncpy(result, result_chars, result_length);
};
void openmm_andersenthermostat_collisionfrequency_(char* result, int result_length) {
const char* result_chars = OpenMM_AndersenThermostat_CollisionFrequency();
strncpy(result, result_chars, result_length);
};
void OPENMM_ANDERSENTHERMOSTAT_COLLISIONFREQUENCY(char* result, int result_length) {
const char* result_chars = OpenMM_AndersenThermostat_CollisionFrequency();
strncpy(result, result_chars, result_length);
};
double openmm_andersenthermostat_getdefaulttemperature_(const OpenMM_AndersenThermostat*& target) {
return OpenMM_AndersenThermostat_getDefaultTemperature(target);
};
double OPENMM_ANDERSENTHERMOSTAT_GETDEFAULTTEMPERATURE(const OpenMM_AndersenThermostat*& target) {
return OpenMM_AndersenThermostat_getDefaultTemperature(target);
};
double openmm_andersenthermostat_getdefaultcollisionfrequency_(const OpenMM_AndersenThermostat*& target) {
return OpenMM_AndersenThermostat_getDefaultCollisionFrequency(target);
};
double OPENMM_ANDERSENTHERMOSTAT_GETDEFAULTCOLLISIONFREQUENCY(const OpenMM_AndersenThermostat*& target) {
return OpenMM_AndersenThermostat_getDefaultCollisionFrequency(target);
};
int openmm_andersenthermostat_getrandomnumberseed_(const OpenMM_AndersenThermostat*& target) {
return OpenMM_AndersenThermostat_getRandomNumberSeed(target);
};
int OPENMM_ANDERSENTHERMOSTAT_GETRANDOMNUMBERSEED(const OpenMM_AndersenThermostat*& target) {
return OpenMM_AndersenThermostat_getRandomNumberSeed(target);
};
void openmm_andersenthermostat_setrandomnumberseed_(OpenMM_AndersenThermostat*& target, int const& seed) {
OpenMM_AndersenThermostat_setRandomNumberSeed(target, seed);
};
void OPENMM_ANDERSENTHERMOSTAT_SETRANDOMNUMBERSEED(OpenMM_AndersenThermostat*& target, int const& seed) {
OpenMM_AndersenThermostat_setRandomNumberSeed(target, seed);
};
/* OpenMM::Platform*/
void openmm_platform_destroy_(OpenMM_Platform*& destroy) {
OpenMM_Platform_destroy(destroy);
destroy = 0;
}
void OPENMM_PLATFORM_DESTROY(OpenMM_Platform*& destroy) {
OpenMM_Platform_destroy(destroy);
destroy = 0;
}
void openmm_platform_getname_(const OpenMM_Platform*& target, char* result, int result_length) {
const char* result_chars = OpenMM_Platform_getName(target);
strncpy(result, result_chars, result_length);
};
void OPENMM_PLATFORM_GETNAME(const OpenMM_Platform*& target, char* result, int result_length) {
const char* result_chars = OpenMM_Platform_getName(target);
strncpy(result, result_chars, result_length);
};
double openmm_platform_getspeed_(const OpenMM_Platform*& target) {
return OpenMM_Platform_getSpeed(target);
};
double OPENMM_PLATFORM_GETSPEED(const OpenMM_Platform*& target) {
return OpenMM_Platform_getSpeed(target);
};
void openmm_platform_supportsdoubleprecision_(const OpenMM_Platform*& target, OpenMM_Boolean& result) {
result = OpenMM_Platform_supportsDoublePrecision(target);
};
void OPENMM_PLATFORM_SUPPORTSDOUBLEPRECISION(const OpenMM_Platform*& target, OpenMM_Boolean& result) {
result = OpenMM_Platform_supportsDoublePrecision(target);
};
void openmm_platform_getpropertynames_(OpenMM_Platform*& target, const OpenMM_StringArray*& result) {
result = OpenMM_Platform_getPropertyNames(target);
};
void OPENMM_PLATFORM_GETPROPERTYNAMES(OpenMM_Platform*& target, const OpenMM_StringArray*& result) {
result = OpenMM_Platform_getPropertyNames(target);
};
void openmm_platform_getpropertyvalue_(const OpenMM_Platform*& target, const OpenMM_Context*& context, const char* property, char* result, int property_length, int result_length) {
const char* result_chars = OpenMM_Platform_getPropertyValue(target, context, string(property, property_length).c_str());
strncpy(result, result_chars, result_length);
};
void OPENMM_PLATFORM_GETPROPERTYVALUE(const OpenMM_Platform*& target, const OpenMM_Context*& context, const char* property, char* result, int property_length, int result_length) {
const char* result_chars = OpenMM_Platform_getPropertyValue(target, context, string(property, property_length).c_str());
strncpy(result, result_chars, result_length);
};
void openmm_platform_setpropertyvalue_(const OpenMM_Platform*& target, OpenMM_Context*& context, const char* property, const char* value, int property_length, int value_length) {
OpenMM_Platform_setPropertyValue(target, context, string(property, property_length).c_str(), string(value, value_length).c_str());
};
void OPENMM_PLATFORM_SETPROPERTYVALUE(const OpenMM_Platform*& target, OpenMM_Context*& context, const char* property, const char* value, int property_length, int value_length) {
OpenMM_Platform_setPropertyValue(target, context, string(property, property_length).c_str(), string(value, value_length).c_str());
};
void openmm_platform_getpropertydefaultvalue_(const OpenMM_Platform*& target, const char* property, char* result, int property_length, int result_length) {
const char* result_chars = OpenMM_Platform_getPropertyDefaultValue(target, string(property, property_length).c_str());
strncpy(result, result_chars, result_length);
};
void OPENMM_PLATFORM_GETPROPERTYDEFAULTVALUE(const OpenMM_Platform*& target, const char* property, char* result, int property_length, int result_length) {
const char* result_chars = OpenMM_Platform_getPropertyDefaultValue(target, string(property, property_length).c_str());
strncpy(result, result_chars, result_length);
};
void openmm_platform_setpropertydefaultvalue_(OpenMM_Platform*& target, const char* property, const char* value, int property_length, int value_length) {
OpenMM_Platform_setPropertyDefaultValue(target, string(property, property_length).c_str(), string(value, value_length).c_str());
};
void OPENMM_PLATFORM_SETPROPERTYDEFAULTVALUE(OpenMM_Platform*& target, const char* property, const char* value, int property_length, int value_length) {
OpenMM_Platform_setPropertyDefaultValue(target, string(property, property_length).c_str(), string(value, value_length).c_str());
};
void openmm_platform_contextcreated_(const OpenMM_Platform*& target, OpenMM_ContextImpl* context) {
OpenMM_Platform_contextCreated(target, context);
};
void OPENMM_PLATFORM_CONTEXTCREATED(const OpenMM_Platform*& target, OpenMM_ContextImpl* context) {
OpenMM_Platform_contextCreated(target, context);
};
void openmm_platform_contextdestroyed_(const OpenMM_Platform*& target, OpenMM_ContextImpl* context) {
OpenMM_Platform_contextDestroyed(target, context);
};
void OPENMM_PLATFORM_CONTEXTDESTROYED(const OpenMM_Platform*& target, OpenMM_ContextImpl* context) {
OpenMM_Platform_contextDestroyed(target, context);
};
void openmm_platform_supportskernels_(const OpenMM_Platform*& target, const OpenMM_StringArray*& kernelNames, OpenMM_Boolean& result) {
result = OpenMM_Platform_supportsKernels(target, kernelNames);
};
void OPENMM_PLATFORM_SUPPORTSKERNELS(const OpenMM_Platform*& target, const OpenMM_StringArray*& kernelNames, OpenMM_Boolean& result) {
result = OpenMM_Platform_supportsKernels(target, kernelNames);
};
void openmm_platform_registerplatform_(OpenMM_Platform*& platform) {
OpenMM_Platform_registerPlatform(platform);
};
void OPENMM_PLATFORM_REGISTERPLATFORM(OpenMM_Platform*& platform) {
OpenMM_Platform_registerPlatform(platform);
};
int openmm_platform_getnumplatforms_() {
return OpenMM_Platform_getNumPlatforms();
};
int OPENMM_PLATFORM_GETNUMPLATFORMS() {
return OpenMM_Platform_getNumPlatforms();
};
void openmm_platform_getplatform_(int const& index, OpenMM_Platform*& result) {
result = OpenMM_Platform_getPlatform(index);
};
void OPENMM_PLATFORM_GETPLATFORM(int const& index, OpenMM_Platform*& result) {
result = OpenMM_Platform_getPlatform(index);
};
void openmm_platform_findplatform_(const OpenMM_StringArray*& kernelNames, OpenMM_Platform*& result) {
result = OpenMM_Platform_findPlatform(kernelNames);
};
void OPENMM_PLATFORM_FINDPLATFORM(const OpenMM_StringArray*& kernelNames, OpenMM_Platform*& result) {
result = OpenMM_Platform_findPlatform(kernelNames);
};
void openmm_platform_loadpluginlibrary_(const char* file, int file_length) {
OpenMM_Platform_loadPluginLibrary(string(file, file_length).c_str());
};
void OPENMM_PLATFORM_LOADPLUGINLIBRARY(const char* file, int file_length) {
OpenMM_Platform_loadPluginLibrary(string(file, file_length).c_str());
};
void openmm_platform_getdefaultpluginsdirectory_(char* result, int result_length) {
const char* result_chars = OpenMM_Platform_getDefaultPluginsDirectory();
strncpy(result, result_chars, result_length);
};
void OPENMM_PLATFORM_GETDEFAULTPLUGINSDIRECTORY(char* result, int result_length) {
const char* result_chars = OpenMM_Platform_getDefaultPluginsDirectory();
strncpy(result, result_chars, result_length);
};
/* OpenMM::State*/
void openmm_state_destroy_(OpenMM_State*& destroy) {
OpenMM_State_destroy(destroy);
destroy = 0;
}
void OPENMM_STATE_DESTROY(OpenMM_State*& destroy) {
OpenMM_State_destroy(destroy);
destroy = 0;
}
double openmm_state_gettime_(const OpenMM_State*& target) {
return OpenMM_State_getTime(target);
};
double OPENMM_STATE_GETTIME(const OpenMM_State*& target) {
return OpenMM_State_getTime(target);
};
void openmm_state_getpositions_(const OpenMM_State*& target, const OpenMM_Vec3Array*& result) {
result = OpenMM_State_getPositions(target);
};
void OPENMM_STATE_GETPOSITIONS(const OpenMM_State*& target, const OpenMM_Vec3Array*& result) {
result = OpenMM_State_getPositions(target);
};
void openmm_state_getvelocities_(const OpenMM_State*& target, const OpenMM_Vec3Array*& result) {
result = OpenMM_State_getVelocities(target);
};
void OPENMM_STATE_GETVELOCITIES(const OpenMM_State*& target, const OpenMM_Vec3Array*& result) {
result = OpenMM_State_getVelocities(target);
};
void openmm_state_getforces_(const OpenMM_State*& target, const OpenMM_Vec3Array*& result) {
result = OpenMM_State_getForces(target);
};
void OPENMM_STATE_GETFORCES(const OpenMM_State*& target, const OpenMM_Vec3Array*& result) {
result = OpenMM_State_getForces(target);
};
double openmm_state_getkineticenergy_(const OpenMM_State*& target) {
return OpenMM_State_getKineticEnergy(target);
};
double OPENMM_STATE_GETKINETICENERGY(const OpenMM_State*& target) {
return OpenMM_State_getKineticEnergy(target);
};
double openmm_state_getpotentialenergy_(const OpenMM_State*& target) {
return OpenMM_State_getPotentialEnergy(target);
};
double OPENMM_STATE_GETPOTENTIALENERGY(const OpenMM_State*& target) {
return OpenMM_State_getPotentialEnergy(target);
};
void openmm_state_getparameters_(const OpenMM_State*& target, const OpenMM_ParameterArray*& result) {
result = OpenMM_State_getParameters(target);
};
void OPENMM_STATE_GETPARAMETERS(const OpenMM_State*& target, const OpenMM_ParameterArray*& result) {
result = OpenMM_State_getParameters(target);
};
/* OpenMM::PeriodicTorsionForce*/
void openmm_periodictorsionforce_create_(OpenMM_PeriodicTorsionForce*& result) {
result = OpenMM_PeriodicTorsionForce_create();
}
void OPENMM_PERIODICTORSIONFORCE_CREATE(OpenMM_PeriodicTorsionForce*& result) {
result = OpenMM_PeriodicTorsionForce_create();
}
void openmm_periodictorsionforce_destroy_(OpenMM_PeriodicTorsionForce*& destroy) {
OpenMM_PeriodicTorsionForce_destroy(destroy);
destroy = 0;
}
void OPENMM_PERIODICTORSIONFORCE_DESTROY(OpenMM_PeriodicTorsionForce*& destroy) {
OpenMM_PeriodicTorsionForce_destroy(destroy);
destroy = 0;
}
int openmm_periodictorsionforce_getnumtorsions_(const OpenMM_PeriodicTorsionForce*& target) {
return OpenMM_PeriodicTorsionForce_getNumTorsions(target);
};
int OPENMM_PERIODICTORSIONFORCE_GETNUMTORSIONS(const OpenMM_PeriodicTorsionForce*& target) {
return OpenMM_PeriodicTorsionForce_getNumTorsions(target);
};
int openmm_periodictorsionforce_addtorsion_(OpenMM_PeriodicTorsionForce*& target, int const& particle1, int const& particle2, int const& particle3, int const& particle4, int const& periodicity, double const& phase, double const& k) {
return OpenMM_PeriodicTorsionForce_addTorsion(target, particle1, particle2, particle3, particle4, periodicity, phase, k);
};
int OPENMM_PERIODICTORSIONFORCE_ADDTORSION(OpenMM_PeriodicTorsionForce*& target, int const& particle1, int const& particle2, int const& particle3, int const& particle4, int const& periodicity, double const& phase, double const& k) {
return OpenMM_PeriodicTorsionForce_addTorsion(target, particle1, particle2, particle3, particle4, periodicity, phase, k);
};
void openmm_periodictorsionforce_gettorsionparameters_(const OpenMM_PeriodicTorsionForce*& target, int const& index, int* particle1, int* particle2, int* particle3, int* particle4, int* periodicity, double* phase, double* k) {
OpenMM_PeriodicTorsionForce_getTorsionParameters(target, index, particle1, particle2, particle3, particle4, periodicity, phase, k);
};
void OPENMM_PERIODICTORSIONFORCE_GETTORSIONPARAMETERS(const OpenMM_PeriodicTorsionForce*& target, int const& index, int* particle1, int* particle2, int* particle3, int* particle4, int* periodicity, double* phase, double* k) {
OpenMM_PeriodicTorsionForce_getTorsionParameters(target, index, particle1, particle2, particle3, particle4, periodicity, phase, k);
};
void openmm_periodictorsionforce_settorsionparameters_(OpenMM_PeriodicTorsionForce*& target, int const& index, int const& particle1, int const& particle2, int const& particle3, int const& particle4, int const& periodicity, double const& phase, double const& k) {
OpenMM_PeriodicTorsionForce_setTorsionParameters(target, index, particle1, particle2, particle3, particle4, periodicity, phase, k);
};
void OPENMM_PERIODICTORSIONFORCE_SETTORSIONPARAMETERS(OpenMM_PeriodicTorsionForce*& target, int const& index, int const& particle1, int const& particle2, int const& particle3, int const& particle4, int const& periodicity, double const& phase, double const& k) {
OpenMM_PeriodicTorsionForce_setTorsionParameters(target, index, particle1, particle2, particle3, particle4, periodicity, phase, k);
};
/* OpenMM::Integrator*/
void openmm_integrator_destroy_(OpenMM_Integrator*& destroy) {
OpenMM_Integrator_destroy(destroy);
destroy = 0;
}
void OPENMM_INTEGRATOR_DESTROY(OpenMM_Integrator*& destroy) {
OpenMM_Integrator_destroy(destroy);
destroy = 0;
}
double openmm_integrator_getstepsize_(const OpenMM_Integrator*& target) {
return OpenMM_Integrator_getStepSize(target);
};
double OPENMM_INTEGRATOR_GETSTEPSIZE(const OpenMM_Integrator*& target) {
return OpenMM_Integrator_getStepSize(target);
};
void openmm_integrator_setstepsize_(OpenMM_Integrator*& target, double const& size) {
OpenMM_Integrator_setStepSize(target, size);
};
void OPENMM_INTEGRATOR_SETSTEPSIZE(OpenMM_Integrator*& target, double const& size) {
OpenMM_Integrator_setStepSize(target, size);
};
double openmm_integrator_getconstrainttolerance_(const OpenMM_Integrator*& target) {
return OpenMM_Integrator_getConstraintTolerance(target);
};
double OPENMM_INTEGRATOR_GETCONSTRAINTTOLERANCE(const OpenMM_Integrator*& target) {
return OpenMM_Integrator_getConstraintTolerance(target);
};
void openmm_integrator_setconstrainttolerance_(OpenMM_Integrator*& target, double const& tol) {
OpenMM_Integrator_setConstraintTolerance(target, tol);
};
void OPENMM_INTEGRATOR_SETCONSTRAINTTOLERANCE(OpenMM_Integrator*& target, double const& tol) {
OpenMM_Integrator_setConstraintTolerance(target, tol);
};
void openmm_integrator_step_(OpenMM_Integrator*& target, int const& steps) {
OpenMM_Integrator_step(target, steps);
};
void OPENMM_INTEGRATOR_STEP(OpenMM_Integrator*& target, int const& steps) {
OpenMM_Integrator_step(target, steps);
};
/* OpenMM::System*/
void openmm_system_create_(OpenMM_System*& result) {
result = OpenMM_System_create();
}
void OPENMM_SYSTEM_CREATE(OpenMM_System*& result) {
result = OpenMM_System_create();
}
void openmm_system_destroy_(OpenMM_System*& destroy) {
OpenMM_System_destroy(destroy);
destroy = 0;
}
void OPENMM_SYSTEM_DESTROY(OpenMM_System*& destroy) {
OpenMM_System_destroy(destroy);
destroy = 0;
}
int openmm_system_getnumparticles_(const OpenMM_System*& target) {
return OpenMM_System_getNumParticles(target);
};
int OPENMM_SYSTEM_GETNUMPARTICLES(const OpenMM_System*& target) {
return OpenMM_System_getNumParticles(target);
};
int openmm_system_addparticle_(OpenMM_System*& target, double const& mass) {
return OpenMM_System_addParticle(target, mass);
};
int OPENMM_SYSTEM_ADDPARTICLE(OpenMM_System*& target, double const& mass) {
return OpenMM_System_addParticle(target, mass);
};
double openmm_system_getparticlemass_(const OpenMM_System*& target, int const& index) {
return OpenMM_System_getParticleMass(target, index);
};
double OPENMM_SYSTEM_GETPARTICLEMASS(const OpenMM_System*& target, int const& index) {
return OpenMM_System_getParticleMass(target, index);
};
void openmm_system_setparticlemass_(OpenMM_System*& target, int const& index, double const& mass) {
OpenMM_System_setParticleMass(target, index, mass);
};
void OPENMM_SYSTEM_SETPARTICLEMASS(OpenMM_System*& target, int const& index, double const& mass) {
OpenMM_System_setParticleMass(target, index, mass);
};
int openmm_system_getnumconstraints_(const OpenMM_System*& target) {
return OpenMM_System_getNumConstraints(target);
};
int OPENMM_SYSTEM_GETNUMCONSTRAINTS(const OpenMM_System*& target) {
return OpenMM_System_getNumConstraints(target);
};
int openmm_system_addconstraint_(OpenMM_System*& target, int const& particle1, int const& particle2, double const& distance) {
return OpenMM_System_addConstraint(target, particle1, particle2, distance);
};
int OPENMM_SYSTEM_ADDCONSTRAINT(OpenMM_System*& target, int const& particle1, int const& particle2, double const& distance) {
return OpenMM_System_addConstraint(target, particle1, particle2, distance);
};
void openmm_system_getconstraintparameters_(const OpenMM_System*& target, int const& index, int* particle1, int* particle2, double* distance) {
OpenMM_System_getConstraintParameters(target, index, particle1, particle2, distance);
};
void OPENMM_SYSTEM_GETCONSTRAINTPARAMETERS(const OpenMM_System*& target, int const& index, int* particle1, int* particle2, double* distance) {
OpenMM_System_getConstraintParameters(target, index, particle1, particle2, distance);
};
void openmm_system_setconstraintparameters_(OpenMM_System*& target, int const& index, int const& particle1, int const& particle2, double const& distance) {
OpenMM_System_setConstraintParameters(target, index, particle1, particle2, distance);
};
void OPENMM_SYSTEM_SETCONSTRAINTPARAMETERS(OpenMM_System*& target, int const& index, int const& particle1, int const& particle2, double const& distance) {
OpenMM_System_setConstraintParameters(target, index, particle1, particle2, distance);
};
int openmm_system_addforce_(OpenMM_System*& target, OpenMM_Force*& force) {
return OpenMM_System_addForce(target, force);
};
int OPENMM_SYSTEM_ADDFORCE(OpenMM_System*& target, OpenMM_Force*& force) {
return OpenMM_System_addForce(target, force);
};
int openmm_system_getnumforces_(const OpenMM_System*& target) {
return OpenMM_System_getNumForces(target);
};
int OPENMM_SYSTEM_GETNUMFORCES(const OpenMM_System*& target) {
return OpenMM_System_getNumForces(target);
};
void openmm_system_getforce_(OpenMM_System*& target, int const& index, OpenMM_Force*& result) {
result = OpenMM_System_getForce(target, index);
};
void OPENMM_SYSTEM_GETFORCE(OpenMM_System*& target, int const& index, OpenMM_Force*& result) {
result = OpenMM_System_getForce(target, index);
};
#if defined(__cplusplus)
}
#endif
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment