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
Hide whitespace changes
Inline Side-by-side
Showing with 4610 additions and 397 deletions
examples/CMakeLists.txt
View file @ c6c034ba
...@@ -13,8 +13,9 @@ ...@@ -13,8 +13,9 @@
# versions of the executable. # versions of the executable.
SET(OpenMM_CWRAPPER "OpenMM_CWrapper") SET(OpenMM_CWRAPPER "OpenMMCWrapper")
SET(OpenMM_FMODULE "OpenMM_Module") SET(OpenMM_FWRAPPER "OpenMMFortranWrapper")
SET(OpenMM_FMODULE "OpenMMFortranModule")
# CWrapper is always a static library but you need a different # CWrapper is always a static library but you need a different
# one if you want to link with the OpenMM static library. # one if you want to link with the OpenMM static library.
...@@ -35,13 +36,15 @@ SET(F_EXAMPLES HelloArgonInFortran HelloSodiumChlorideInFortran) ...@@ -35,13 +36,15 @@ SET(F_EXAMPLES HelloArgonInFortran HelloSodiumChlorideInFortran)
SET(BUILD_TESTING_SHARED 1) SET(BUILD_TESTING_SHARED 1)
SET(BUILD_TESTING_STATIC 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} SET_TARGET_PROPERTIES(${CWRAPPER_FOR_SHARED}
PROPERTIES PROPERTIES
PROJECT_LABEL "C Bindings") PROJECT_LABEL "C Bindings")
TARGET_LINK_LIBRARIES(${CWRAPPER_FOR_SHARED} ${SHARED_TARGET}) 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} SET_TARGET_PROPERTIES(${CWRAPPER_FOR_STATIC}
PROPERTIES PROPERTIES
COMPILE_FLAGS "-DOPENMM_USE_STATIC_LIBRARIES" COMPILE_FLAGS "-DOPENMM_USE_STATIC_LIBRARIES"
...@@ -109,11 +112,12 @@ FOREACH(EX_ROOT ${F_EXAMPLES}) ...@@ -109,11 +112,12 @@ FOREACH(EX_ROOT ${F_EXAMPLES})
INSTALL(FILES ${EX_ROOT}.f90 DESTINATION examples) INSTALL(FILES ${EX_ROOT}.f90 DESTINATION examples)
ENDFOREACH(EX_ROOT ${F_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 ${OpenMM_FMODULE}.f90 DESTINATION examples)
INSTALL(FILES README.txt DESTINATION examples) INSTALL(FILES README.txt DESTINATION examples)
INSTALL(FILES Makefile DESTINATION examples) INSTALL(FILES Makefile NMakefile DESTINATION examples)
INSTALL(FILES HelloArgonVS8/HelloArgon.vcproj INSTALL(FILES HelloArgonVS8/HelloArgon.vcproj
HelloArgonVS8/HelloArgon.sln HelloArgonVS8/HelloArgon.sln
......
examples/HelloArgonInC.c
View file @ c6c034ba
...@@ -11,7 +11,7 @@ ...@@ -11,7 +11,7 @@
* other visualization tool to produce an animation of the resulting trajectory. * other visualization tool to produce an animation of the resulting trajectory.
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
#include "OpenMM_CWrapper.h" #include "OpenMMCWrapper.h"
#include <stdio.h> #include <stdio.h>
/* Forward declaration of routine for printing one frame of the /* Forward declaration of routine for printing one frame of the
...@@ -23,6 +23,7 @@ void simulateArgon() ...@@ -23,6 +23,7 @@ void simulateArgon()
OpenMM_System* system; OpenMM_System* system;
OpenMM_Integrator* integrator; OpenMM_Integrator* integrator;
OpenMM_Context* context; OpenMM_Context* context;
OpenMM_Platform* platform;
OpenMM_NonbondedForce* nonbond; OpenMM_NonbondedForce* nonbond;
OpenMM_Vec3Array* initPosInNm; OpenMM_Vec3Array* initPosInNm;
int a, frameNum; int a, frameNum;
...@@ -41,7 +42,7 @@ void simulateArgon() ...@@ -41,7 +42,7 @@ void simulateArgon()
initPosInNm = OpenMM_Vec3Array_create(3); initPosInNm = OpenMM_Vec3Array_create(3);
for (a = 0; a < 3; ++a) 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_Vec3Array_set(initPosInNm, a, posNm);
OpenMM_System_addParticle(system, 39.95); /*mass of Ar, grams/mole*/ OpenMM_System_addParticle(system, 39.95); /*mass of Ar, grams/mole*/
...@@ -55,8 +56,9 @@ void simulateArgon() ...@@ -55,8 +56,9 @@ void simulateArgon()
/* Let OpenMM Context choose best platform. */ /* Let OpenMM Context choose best platform. */
context = OpenMM_Context_create(system, integrator); context = OpenMM_Context_create(system, integrator);
platform = OpenMM_Context_getPlatform(context);
printf( "REMARK Using OpenMM platform %s\n", 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. */ /* Set starting positions of the atoms. Leave time and velocity zero. */
OpenMM_Context_setPositions(context, initPosInNm); OpenMM_Context_setPositions(context, initPosInNm);
...@@ -64,7 +66,7 @@ void simulateArgon() ...@@ -64,7 +66,7 @@ void simulateArgon()
/* Simulate. */ /* Simulate. */
for (frameNum=1; ;++frameNum) { for (frameNum=1; ;++frameNum) {
/* Output current state information. */ /* 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); const double timeInPs = OpenMM_State_getTime(state);
writePdbFrame(frameNum, state); /*output coordinates*/ writePdbFrame(frameNum, state); /*output coordinates*/
OpenMM_State_destroy(state); OpenMM_State_destroy(state);
...@@ -99,14 +101,14 @@ void writePdbFrame(int frameNum, const OpenMM_State* state) ...@@ -99,14 +101,14 @@ void writePdbFrame(int frameNum, const OpenMM_State* state)
/* Use PDB MODEL cards to number trajectory frames. */ /* Use PDB MODEL cards to number trajectory frames. */
printf("MODEL %d\n", frameNum); /*start of frame*/ 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 */ /* "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("ATOM %5d AR AR 1 ", a+1); /*atom number*/
printf("%8.3f%8.3f%8.3f 1.00 0.00\n", /*coordinates*/ 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*/ printf("ENDMDL\n"); /*end of frame*/
} }
examples/HelloArgonInCVS8/HelloArgonInC.vcproj
View file @ c6c034ba
...@@ -61,7 +61,7 @@ ...@@ -61,7 +61,7 @@
/> />
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
AdditionalDependencies="OpenMM_CWrapper_d.lib OpenMM_d.lib" AdditionalDependencies="OpenMMCWrapper_d.lib OpenMM_d.lib"
LinkIncremental="2" LinkIncremental="2"
AdditionalLibraryDirectories="&quot;$(ProgramFiles)\OpenMM\lib&quot;" AdditionalLibraryDirectories="&quot;$(ProgramFiles)\OpenMM\lib&quot;"
GenerateDebugInformation="true" GenerateDebugInformation="true"
...@@ -137,7 +137,7 @@ ...@@ -137,7 +137,7 @@
/> />
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
AdditionalDependencies="OpenMM_CWrapper.lib OpenMM.lib" AdditionalDependencies="OpenMMCWrapper.lib OpenMM.lib"
LinkIncremental="1" LinkIncremental="1"
AdditionalLibraryDirectories="&quot;$(ProgramFiles)\OpenMM\lib&quot;" AdditionalLibraryDirectories="&quot;$(ProgramFiles)\OpenMM\lib&quot;"
GenerateDebugInformation="true" GenerateDebugInformation="true"
......
examples/HelloArgonInFortran.f90
View file @ c6c034ba
...@@ -16,19 +16,20 @@ PROGRAM HelloArgon ...@@ -16,19 +16,20 @@ PROGRAM HelloArgon
type(OpenMM_System) system type(OpenMM_System) system
type(OpenMM_VerletIntegrator) verlet type(OpenMM_VerletIntegrator) verlet
type(OpenMM_Context) context type(OpenMM_Context) context
type(OpenMM_Platform) platform
type(OpenMM_NonbondedForce) nonbond type(OpenMM_NonbondedForce) nonbond
type(OpenMM_Vec3Array) initPosInNm type(OpenMM_Vec3Array) initPosInNm
type(OpenMM_State) state type(OpenMM_State) state
type(OpenMM_String) dirName type(OpenMM_StringArray) pluginList
real*8 timeInPs real*8 timeInPs
integer*4 a, ix, frameNum integer*4 a, ix, frameNum
character*10 platformName character*10 platformName
character*100 dirName
! Load any shared libraries containing GPU implementations. ! Load any shared libraries containing GPU implementations.
call OpenMM_String_create(dirName,'') call OpenMM_Platform_getDefaultPluginsDirectory(dirName)
call OpenMM_Platform_getDefaultPluginsDirectory(dirName) call OpenMM_Platform_loadPluginsFromDirectory(dirName, pluginList)
call OpenMM_Platform_loadPluginsFromDirectory(dirName) call OpenMM_StringArray_destroy(pluginList)
call OpenMM_String_destroy(dirName)
! Create a system with nonbonded forces. System takes ownership ! Create a system with nonbonded forces. System takes ownership
! of Force; don't destroy it yourself. (We're using transfer here ! of Force; don't destroy it yourself. (We're using transfer here
...@@ -36,13 +37,13 @@ PROGRAM HelloArgon ...@@ -36,13 +37,13 @@ PROGRAM HelloArgon
call OpenMM_System_create(system) call OpenMM_System_create(system)
call OpenMM_NonbondedForce_create(nonbond) call OpenMM_NonbondedForce_create(nonbond)
ix = OpenMM_System_addForce(system, transfer(nonbond, OpenMM_Force(0))) ix = OpenMM_System_addForce(system, transfer(nonbond, OpenMM_Force(0)))
! Create three atoms. ! Create three atoms.
call OpenMM_Vec3Array_create(initPosInNm, 3) call OpenMM_Vec3Array_create(initPosInNm, 3)
do a=1,3 do a=1,3
! Space the atoms out evenly by atom index. ! Space the atoms out evenly by atom index.
call OpenMM_Vec3Array_set(initPosInNm, a, (/ 0.5d0*(a-1), 0d0, 0d0 /)) call OpenMM_Vec3Array_set(initPosInNm, a, (/ 0.5d0*(a-1), 0d0, 0d0 /))
ix = OpenMM_System_addParticle(system, 39.95d0) !mass of Ar, grams/mole ix = OpenMM_System_addParticle(system, 39.95d0) !mass of Ar, grams/mole
! charge, L-J sigma (nm), well depth (kJ) (vdWRad(Ar)=.188 nm) ! charge, L-J sigma (nm), well depth (kJ) (vdWRad(Ar)=.188 nm)
...@@ -55,7 +56,8 @@ PROGRAM HelloArgon ...@@ -55,7 +56,8 @@ PROGRAM HelloArgon
! Let OpenMM Context choose best platform. ! Let OpenMM Context choose best platform.
call OpenMM_Context_create(context, system, & call OpenMM_Context_create(context, system, &
transfer(verlet, OpenMM_Integrator(0))) 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 print "('REMARK Using OpenMM platform ', A)", platformName
! Set starting positions of the atoms. Leave time and velocity zero. ! Set starting positions of the atoms. Leave time and velocity zero.
...@@ -65,7 +67,7 @@ PROGRAM HelloArgon ...@@ -65,7 +67,7 @@ PROGRAM HelloArgon
frameNum = 1 frameNum = 1
do do
! Output current state information. ! 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) timeInPs = OpenMM_State_getTime(state)
call writePdbFrame(frameNum, state) !output coordinates call writePdbFrame(frameNum, state) !output coordinates
call OpenMM_State_destroy(state) call OpenMM_State_destroy(state)
...@@ -93,16 +95,17 @@ SUBROUTINE writePDBFrame(frameNum, state) ...@@ -93,16 +95,17 @@ SUBROUTINE writePDBFrame(frameNum, state)
integer frameNum integer frameNum
type(OpenMM_State) state type(OpenMM_State) state
type(OpenMM_Vec3Array) posInNm type(OpenMM_Vec3Array) allPosInNm
real*8 posInAng(3) real*8 posInNm(3), posInAng(3)
integer n integer n
! Reference atomic positions in the OpenMM State. ! 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 print "('MODEL',5X,I0)", frameNum ! start of frame
do n = 1,OpenMM_Vec3Array_size(posInNm) do n = 1,OpenMM_Vec3Array_getSize(allPosInNm)
call OpenMM_Vec3Array_getScaled(posInNm, n, 10d0, posInAng) 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')", & print "('ATOM ', I5, ' AR AR 1 ', 3F8.3, ' 1.00 0.00')", &
n, posInAng n, posInAng
end do end do
......
examples/HelloArgonInFortranVS8/HelloArgonInFortran.vfproj
View file @ c6c034ba
...@@ -5,7 +5,7 @@ ...@@ -5,7 +5,7 @@
<Configurations> <Configurations>
<Configuration Name="Debug|Win32"> <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="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="VFResourceCompilerTool"/>
<Tool Name="VFMidlTool" SuppressStartupBanner="true"/> <Tool Name="VFMidlTool" SuppressStartupBanner="true"/>
<Tool Name="VFCustomBuildTool"/> <Tool Name="VFCustomBuildTool"/>
...@@ -15,7 +15,7 @@ ...@@ -15,7 +15,7 @@
<Tool Name="VFManifestTool" SuppressStartupBanner="true"/></Configuration> <Tool Name="VFManifestTool" SuppressStartupBanner="true"/></Configuration>
<Configuration Name="Release|Win32"> <Configuration Name="Release|Win32">
<Tool Name="VFFortranCompilerTool" SuppressStartupBanner="true" RuntimeLibrary="rtMultiThreadedDLL"/> <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="VFResourceCompilerTool"/>
<Tool Name="VFMidlTool" SuppressStartupBanner="true"/> <Tool Name="VFMidlTool" SuppressStartupBanner="true"/>
<Tool Name="VFCustomBuildTool"/> <Tool Name="VFCustomBuildTool"/>
...@@ -28,5 +28,5 @@ ...@@ -28,5 +28,5 @@
<Filter Name="Resource Files" Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"/> <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"> <Filter Name="Source Files" Filter="f90;for;f;fpp;ftn;def;odl;idl">
<File RelativePath="..\HelloArgonInFortran.f90"/> <File RelativePath="..\HelloArgonInFortran.f90"/>
<File RelativePath="..\OpenMM_Module.f90"/></Filter></Files> <File RelativePath="..\OpenMMFortranModule.f90"/></Filter></Files>
<Globals/></VisualStudioProject> <Globals/></VisualStudioProject>
examples/HelloSodiumChlorideInC.c
View file @ c6c034ba
...@@ -158,7 +158,7 @@ int main() { ...@@ -158,7 +158,7 @@ int main() {
* can use the implementation from the C++ version of this example if you * 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. * want. However, the methods are reimplemented in C below in case you prefer.
*/ */
#include "OpenMM_CWrapper.h" #include "OpenMMCWrapper.h"
struct MyOpenMMData_s { struct MyOpenMMData_s {
...@@ -200,6 +200,7 @@ myInitializeOpenMM( const MyAtomInfo atoms[], ...@@ -200,6 +200,7 @@ myInitializeOpenMM( const MyAtomInfo atoms[],
OpenMM_Vec3Array* initialPosInNm; OpenMM_Vec3Array* initialPosInNm;
OpenMM_NonbondedForce* nonbond; OpenMM_NonbondedForce* nonbond;
OpenMM_GBSAOBCForce* gbsa; OpenMM_GBSAOBCForce* gbsa;
OpenMM_Platform* platform;
int n; int n;
/* Load all available OpenMM plugins from their default location. */ /* Load all available OpenMM plugins from their default location. */
...@@ -227,7 +228,7 @@ myInitializeOpenMM( const MyAtomInfo atoms[], ...@@ -227,7 +228,7 @@ myInitializeOpenMM( const MyAtomInfo atoms[],
initialPosInNm = OpenMM_Vec3Array_create(0); initialPosInNm = OpenMM_Vec3Array_create(0);
for (n=0; *atoms[n].pdb; ++n) { for (n=0; *atoms[n].pdb; ++n) {
const MyAtomInfo* atom = &atoms[n]; const MyAtomInfo* atom = &atoms[n];
double posInNm[3]; OpenMM_Vec3 posInNm;
OpenMM_System_addParticle(omm->system, atom->mass); OpenMM_System_addParticle(omm->system, atom->mass);
...@@ -243,7 +244,7 @@ myInitializeOpenMM( const MyAtomInfo atoms[], ...@@ -243,7 +244,7 @@ myInitializeOpenMM( const MyAtomInfo atoms[],
atom->gbsaScaleFactor); atom->gbsaScaleFactor);
/* Convert the initial position to nm and append to the array. */ /* 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); OpenMM_Vec3Array_append(initialPosInNm, posInNm);
} }
...@@ -258,7 +259,8 @@ myInitializeOpenMM( const MyAtomInfo atoms[], ...@@ -258,7 +259,8 @@ myInitializeOpenMM( const MyAtomInfo atoms[],
omm->context = OpenMM_Context_create(omm->system, omm->integrator); omm->context = OpenMM_Context_create(omm->system, omm->integrator);
OpenMM_Context_setPositions(omm->context, initialPosInNm); 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; return omm;
} }
...@@ -286,7 +288,7 @@ myGetOpenMMState(MyOpenMMData* omm, int wantEnergy, ...@@ -286,7 +288,7 @@ myGetOpenMMState(MyOpenMMData* omm, int wantEnergy,
/* Forces are also available (and cheap). */ /* Forces are also available (and cheap). */
/* State object is created here and must be explicitly destroyed below. */ /* 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. */ *timeInPs = OpenMM_State_getTime(state); /* OpenMM time is in ps already. */
/* Positions are maintained as a Vec3Array inside the State. This will give /* Positions are maintained as a Vec3Array inside the State. This will give
...@@ -294,8 +296,9 @@ myGetOpenMMState(MyOpenMMData* omm, int wantEnergy, ...@@ -294,8 +296,9 @@ myGetOpenMMState(MyOpenMMData* omm, int wantEnergy,
posArrayInNm = OpenMM_State_getPositions(state); posArrayInNm = OpenMM_State_getPositions(state);
for (n=0; *atoms[n].pdb; ++n) for (n=0; *atoms[n].pdb; ++n)
/* Sets atoms[n].pos = posArray[n] * Angstroms/nm. */ /* Sets atoms[n].pos = posArray[n] * Angstroms/nm. */
OpenMM_Vec3Array_getScaled(posArrayInNm, n, OpenMM_AngstromsPerNm, *(OpenMM_Vec3*)atoms[n].posInAng =
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. */ /* If energy has been requested, obtain it and convert from kJ to kcal. */
*energyInKcal = 0; *energyInKcal = 0;
......
examples/HelloSodiumChlorideInFortran.f90
View file @ c6c034ba
! ----------------------------------------------------------------------------- ! -----------------------------------------------------------------------------
! OpenMM(tm) HelloSodiumChloride example in Fortran 95 (June 2009) ! OpenMM(tm) HelloSodiumChloride example in Fortran 95 (June 2009)
! ------------------------------------------------------------------------------ ! ------------------------------------------------------------------------------
! This is a complete, self-contained "hello world" example demonstrating ! This is a complete, self-contained "hello world" example demonstrating
! GPU-accelerated constant temperature simulation of a very simple system with ! GPU-accelerated constant temperature simulation of a very simple system with
! just nonbonded forces, consisting of several sodium (Na+) and chloride (Cl-) ! just nonbonded forces, consisting of several sodium (Na+) and chloride (Cl-)
! ions in implicit solvent. A multi-frame PDB file is written to stdout which ! ions in implicit solvent. A multi-frame PDB file is written to stdout which
! can be read by VMD or other visualization tool to produce an animation of the ! can be read by VMD or other visualization tool to produce an animation of the
! resulting trajectory. ! resulting trajectory.
! !
! Pay particular attention to the handling of units in this example. Incorrect ! Pay particular attention to the handling of units in this example. Incorrect
! handling of units is a very common error; this example shows how you can ! handling of units is a very common error; this example shows how you can
! continue to work with Amber-style units like Angstroms, kCals, and van der ! continue to work with Amber-style units like Angstroms, kCals, and van der
! Waals radii while correctly communicating with OpenMM in nm, kJ, and sigma. ! Waals radii while correctly communicating with OpenMM in nm, kJ, and sigma.
! !
! This example is written entirely in Fortran 95, using a Fortran interface ! This example is written entirely in Fortran 95, using a Fortran interface
! module which is NOT official parts of the OpenMM distribution. ! module which is NOT official parts of the OpenMM distribution.
! ------------------------------------------------------------------------------ ! ------------------------------------------------------------------------------
!------------------------------------------------------------------------------- !-------------------------------------------------------------------------------
! ATOM, FORCE FIELD, AND SIMULATION PARAMETERS ! ATOM, FORCE FIELD, AND SIMULATION PARAMETERS
!------------------------------------------------------------------------------- !-------------------------------------------------------------------------------
! We'll define this module as a simplified example of the kinds of data ! We'll define this module as a simplified example of the kinds of data
! structures that may already be in an MD program that is to be converted ! structures that may already be in an MD program that is to be converted
! to use OpenMM. Note that we're using data in Angstrom and kcal units; we'll ! to use OpenMM. Note that we're using data in Angstrom and kcal units; we'll
! show how to safely convert to and from OpenMM's internal units as we go. ! show how to safely convert to and from OpenMM's internal units as we go.
MODULE MyAtomInfo MODULE MyAtomInfo
! Simulation parameters ! Simulation parameters
! --------------------- ! ---------------------
real*8 Temperature, FrictionInPerPs, SolventDielectric, SoluteDielectric real*8 Temperature, FrictionInPerPs, SolventDielectric, SoluteDielectric
parameter(Temperature = 300) !Kelvins parameter(Temperature = 300) !Kelvins
parameter(FrictionInPerPs = 91) !collisions per picosecond parameter(FrictionInPerPs = 91) !collisions per picosecond
parameter(SolventDielectric = 80) !typical for water parameter(SolventDielectric = 80) !typical for water
parameter(SoluteDielectric = 2) !typical for protein parameter(SoluteDielectric = 2) !typical for protein
real*8 StepSizeInFs, ReportIntervalInFs, SimulationTimeInPs real*8 StepSizeInFs, ReportIntervalInFs, SimulationTimeInPs
parameter(StepSizeInFs = 2) !integration step size (fs) parameter(StepSizeInFs = 2) !integration step size (fs)
parameter(ReportIntervalInFs = 50) !how often for PDB frame (fs) parameter(ReportIntervalInFs = 50) !how often for PDB frame (fs)
parameter(SimulationTimeInPs = 100) !total simulation time (ps) parameter(SimulationTimeInPs = 100) !total simulation time (ps)
! Currently energy calculation is not available in the GPU kernels so ! Currently energy calculation is not available in the GPU kernels so
! asking for it requires slow Reference Platform computation at ! asking for it requires slow Reference Platform computation at
! reporting intervals. If you have a big system you'll want this off. ! reporting intervals. If you have a big system you'll want this off.
logical, parameter :: WantEnergy = .true. logical, parameter :: WantEnergy = .true.
! Atom and force field information ! Atom and force field information
! -------------------------------- ! --------------------------------
type Atom type Atom
character*4 pdb character*4 pdb
real*8 mass, charge, vdwRadiusInAng, vdwEnergyInKcal real*8 mass, charge, vdwRadiusInAng, vdwEnergyInKcal
real*8 gbsaRadiusInAng, gbsaScaleFactor real*8 gbsaRadiusInAng, gbsaScaleFactor
real*8 initPosInAng(3) real*8 initPosInAng(3)
real*8 posInAng(3) ! leave room for runtime state info real*8 posInAng(3) ! leave room for runtime state info
end type end type
integer, parameter :: NumAtoms = 6 integer, parameter :: NumAtoms = 6
type (Atom) :: atoms(NumAtoms) = (/ & type (Atom) :: atoms(NumAtoms) = (/ &
! pdb mass charge vdwRad vdwEnergy gbRad gbScale initPos runtime ! pdb mass charge vdwRad vdwEnergy gbRad gbScale initPos runtime
Atom(' NA ',22.99, 1, 1.8680, 0.00277, 1.992, 0.8, (/ 8, 0, 0/), (/0,0,0/)),& Atom(' NA ',22.99, 1, 1.8680, 0.00277, 1.992, 0.8, (/ 8, 0, 0/), (/0,0,0/)),&
Atom(' CL ',35.45, -1, 2.4700, 0.1000, 1.735, 0.8, (/-8, 0, 0/), (/0,0,0/)),& Atom(' CL ',35.45, -1, 2.4700, 0.1000, 1.735, 0.8, (/-8, 0, 0/), (/0,0,0/)),&
Atom(' NA ',22.99, 1, 1.8680, 0.00277, 1.992, 0.8, (/ 0, 9, 0/), (/0,0,0/)),& Atom(' NA ',22.99, 1, 1.8680, 0.00277, 1.992, 0.8, (/ 0, 9, 0/), (/0,0,0/)),&
Atom(' CL ',35.45, -1, 2.4700, 0.1000, 1.735, 0.8, (/ 0,-9, 0/), (/0,0,0/)),& Atom(' CL ',35.45, -1, 2.4700, 0.1000, 1.735, 0.8, (/ 0,-9, 0/), (/0,0,0/)),&
Atom(' NA ',22.99, 1, 1.8680, 0.00277, 1.992, 0.8, (/ 0, 0,-10/), (/0,0,0/)),& Atom(' NA ',22.99, 1, 1.8680, 0.00277, 1.992, 0.8, (/ 0, 0,-10/), (/0,0,0/)),&
Atom(' CL ',35.45, -1, 2.4700, 0.1000, 1.735, 0.8, (/ 0, 0, 10/), (/0,0,0/)) & Atom(' CL ',35.45, -1, 2.4700, 0.1000, 1.735, 0.8, (/ 0, 0, 10/), (/0,0,0/)) &
/) /)
END MODULE END MODULE
!------------------------------------------------------------------------------- !-------------------------------------------------------------------------------
! MAIN PROGRAM ! MAIN PROGRAM
!------------------------------------------------------------------------------- !-------------------------------------------------------------------------------
! This makes use of four subroutines that encapsulate all the OpenMM calls: ! This makes use of four subroutines that encapsulate all the OpenMM calls:
! myInitializeOpenMM ! myInitializeOpenMM
! myStepWithOpenMM ! myStepWithOpenMM
! myGetOpenMMState ! myGetOpenMMState
! myTerminateOpenMM ! myTerminateOpenMM
! and one minimalist PDB file writer that has nothing to do with OpenMM: ! and one minimalist PDB file writer that has nothing to do with OpenMM:
! myWritePDBFrame ! myWritePDBFrame
! All of these subroutines can be found later in this file. For use in a real ! All of these subroutines can be found later in this file. For use in a real
! MD code you would need to write your own interface routines along these lines. ! MD code you would need to write your own interface routines along these lines.
! Note that the main program does NOT include the OpenMM module. ! Note that the main program does NOT include the OpenMM module.
PROGRAM HelloSodiumChloride PROGRAM HelloSodiumChloride
use MyAtomInfo use MyAtomInfo
! Calculate the number of PDB frames we want to write out and how ! Calculate the number of PDB frames we want to write out and how
! many steps to take on the GPU in between. ! many steps to take on the GPU in between.
integer NumReports, NumSilentSteps integer NumReports, NumSilentSteps
parameter(NumReports = (SimulationTimeInPs*1000 / ReportIntervalInFs + 0.5)) parameter(NumReports = (SimulationTimeInPs*1000 / ReportIntervalInFs + 0.5))
parameter(NumSilentSteps = (ReportIntervalInFs / StepSizeInFs + 0.5)) parameter(NumSilentSteps = (ReportIntervalInFs / StepSizeInFs + 0.5))
character*10 platformName; real*8 timeInPs, energyInKcal; integer frame character*10 platformName; real*8 timeInPs, energyInKcal; integer frame
! This is an opaque handle to a container that holds the OpenMM runtime ! This is an opaque handle to a container that holds the OpenMM runtime
! objects. You can use any type for this purpose as long as it is ! objects. You can use any type for this purpose as long as it is
! big enough to hold a pointer. (If you use a pointer type you'll have ! big enough to hold a pointer. (If you use a pointer type you'll have
! to declare the subroutine interfaces before calling them.) ! to declare the subroutine interfaces before calling them.)
integer*8 ommHandle integer*8 ommHandle
! Set up OpenMM data structures; returns platform name and handle. ! Set up OpenMM data structures; returns platform name and handle.
call myInitializeOpenMM(ommHandle, platformName) call myInitializeOpenMM(ommHandle, platformName)
! Run the simulation: ! Run the simulation:
! (1) Write the first line of the PDB file and the initial configuration. ! (1) Write the first line of the PDB file and the initial configuration.
! (2) Run silently entirely within OpenMM between reporting intervals. ! (2) Run silently entirely within OpenMM between reporting intervals.
! (3) Write a PDB frame when the time comes. ! (3) Write a PDB frame when the time comes.
print "('REMARK Using OpenMM platform ', A)", platformName print "('REMARK Using OpenMM platform ', A)", platformName
call myGetOpenMMState(ommHandle, timeInPs, energyInKcal) call myGetOpenMMState(ommHandle, timeInPs, energyInKcal)
call myWritePDBFrame(0, timeInPs, energyInKcal) call myWritePDBFrame(0, timeInPs, energyInKcal)
do frame = 1, NumReports do frame = 1, NumReports
call myStepWithOpenMM(ommHandle, NumSilentSteps) call myStepWithOpenMM(ommHandle, NumSilentSteps)
call myGetOpenMMState(ommHandle, timeInPs, energyInKcal) call myGetOpenMMState(ommHandle, timeInPs, energyInKcal)
call myWritePDBFrame(frame, timeInPs, energyInKcal) call myWritePDBFrame(frame, timeInPs, energyInKcal)
end do end do
! Clean up OpenMM data structures. ! Clean up OpenMM data structures.
call myTerminateOpenMM(ommHandle) call myTerminateOpenMM(ommHandle)
END PROGRAM END PROGRAM
!------------------------------------------------------------------------------- !-------------------------------------------------------------------------------
! PDB FILE WRITER ! PDB FILE WRITER
!------------------------------------------------------------------------------- !-------------------------------------------------------------------------------
! Given state data which was written into the atoms array of the MyAtomInfo ! Given state data which was written into the atoms array of the MyAtomInfo
! module, output a single frame (pdb "model") of the trajectory. This has ! module, output a single frame (pdb "model") of the trajectory. This has
! nothing to do with OpenMM. ! nothing to do with OpenMM.
SUBROUTINE myWritePDBFrame(frameNum, timeInPs, energyInKcal) SUBROUTINE myWritePDBFrame(frameNum, timeInPs, energyInKcal)
use MyAtomInfo; implicit none use MyAtomInfo; implicit none
integer frameNum; real*8 timeInPs, energyInKcal integer frameNum; real*8 timeInPs, energyInKcal
integer n integer n
print "('MODEL',5X,I0)", frameNum print "('MODEL',5X,I0)", frameNum
print "('REMARK 250 time=', F0.3, ' picoseconds; Energy=', F0.3, ' kcal/mole')", & print "('REMARK 250 time=', F0.3, ' picoseconds; Energy=', F0.3, ' kcal/mole')", &
timeInPs, energyInKcal timeInPs, energyInKcal
do n = 1,NumAtoms do n = 1,NumAtoms
print "('ATOM ', I5, ' ', A4, ' SLT 1 ', 3F8.3, ' 1.00 0.00')", & print "('ATOM ', I5, ' ', A4, ' SLT 1 ', 3F8.3, ' 1.00 0.00')", &
n, atoms(n)%pdb, atoms(n)%posInAng n, atoms(n)%pdb, atoms(n)%posInAng
end do end do
print "('ENDMDL')" print "('ENDMDL')"
END SUBROUTINE END SUBROUTINE
!------------------------------------------------------------------------------- !-------------------------------------------------------------------------------
! OpenMM-USING CODE ! OpenMM-USING CODE
!------------------------------------------------------------------------------- !-------------------------------------------------------------------------------
! The OpenMM Fortran interface module is included only at this point and below. ! The OpenMM Fortran interface module is included only at this point and below.
! Normally these subroutines would be in a separate compilation module; we're ! Normally these subroutines would be in a separate compilation module; we're
! including them here for simplicity. We suggest that you write them in C++ ! including them here for simplicity. We suggest that you write them in C++
! if possible, using extern "C" functions to make then callable from your ! if possible, using extern "C" functions to make then callable from your
! Fortran main program. (See the C++ version of this example program for ! Fortran main program. (See the C++ version of this example program for
! an implementation of very similar routines.) However, these routines are ! an implementation of very similar routines.) However, these routines are
! reimplemented entirely in Fortran 95 below in case you prefer. ! reimplemented entirely in Fortran 95 below in case you prefer.
! ------------------------------------------------------------------------------ ! ------------------------------------------------------------------------------
! INITIALIZE OpenMM DATA STRUCTURES ! INITIALIZE OpenMM DATA STRUCTURES
! ------------------------------------------------------------------------------ ! ------------------------------------------------------------------------------
! We take these actions here: ! We take these actions here:
! (1) Load any available OpenMM plugins, e.g. Cuda and Brook. ! (1) Load any available OpenMM plugins, e.g. Cuda and Brook.
! (2) Fill the OpenMM::System with the force field parameters we want to ! (2) Fill the OpenMM::System with the force field parameters we want to
! use and the particular set of atoms to be simulated. ! use and the particular set of atoms to be simulated.
! (3) Create an Integrator and a Context associating the Integrator with ! (3) Create an Integrator and a Context associating the Integrator with
! the System. ! the System.
! (4) Select the OpenMM platform to be used. ! (4) Select the OpenMM platform to be used.
! (5) Allocate a RuntimeObjects container to hang on to the System, ! (5) Allocate a RuntimeObjects container to hang on to the System,
! Integrator, and Context. ! Integrator, and Context.
! (6) Return an opaque handle to the RuntimeObjects and the name of the ! (6) Return an opaque handle to the RuntimeObjects and the name of the
! Platform in use. ! Platform in use.
! !
! Note that this routine must understand the calling MD code's molecule and ! Note that this routine must understand the calling MD code's molecule and
! force field data structures so will need to be customized for each MD code. ! force field data structures so will need to be customized for each MD code.
SUBROUTINE myInitializeOpenMM(ommHandle, platformName) SUBROUTINE myInitializeOpenMM(ommHandle, platformName)
use OpenMM; use MyAtomInfo; implicit none use OpenMM; use MyAtomInfo; implicit none
integer*8, intent(out) :: ommHandle integer*8, intent(out) :: ommHandle
character*10, intent(out) :: platformName character*10, intent(out) :: platformName
! This is the actual type of the opaque handle. ! This is the actual type of the opaque handle.
type (OpenMM_RuntimeObjects) omm type (OpenMM_RuntimeObjects) omm
! These are the objects we'll create here and store in the ! These are the objects we'll create here and store in the
! RuntimeObjects container for later access. ! RuntimeObjects container for later access.
type (OpenMM_System) system type (OpenMM_System) system
type (OpenMM_LangevinIntegrator) langevin type (OpenMM_LangevinIntegrator) langevin
type (OpenMM_Context) context type (OpenMM_Context) context
! These are temporary OpenMM objects used and discarded here. ! These are temporary OpenMM objects used and discarded here.
type(OpenMM_Vec3Array) initialPosInNm type (OpenMM_StringArray) pluginList
type(OpenMM_NonbondedForce) nonbond type (OpenMM_Vec3Array) initialPosInNm
type(OpenMM_GBSAOBCForce) gbsa type (OpenMM_NonbondedForce) nonbond
integer*4 n, ix type (OpenMM_GBSAOBCForce) gbsa
type (OpenMM_Platform) platform
type(OpenMM_String) dir character*100 dirName
integer*4 n, ix
! Create a string, get the name of the default plugins directory, real*8 posInNm(3)
! and then load all the plugins found there.
call OpenMM_String_create(dir, '') ! Get the name of the default plugins directory,
call OpenMM_Platform_getDefaultPluginsDirectory(dir) ! and then load all the plugins found there.
call OpenMM_Platform_loadPluginsFromDirectory(dir) call OpenMM_Platform_getDefaultPluginsDirectory(dirName)
call OpenMM_String_destroy(dir) 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. ! Create a System and Force objects for it. The System will take
call OpenMM_System_create(system) ! over ownership of the Forces; don't destroy them yourself.
call OpenMM_NonbondedForce_create(nonbond) call OpenMM_System_create(system)
call OpenMM_GBSAOBCForce_create(gbsa) call OpenMM_NonbondedForce_create(nonbond)
call OpenMM_GBSAOBCForce_create(gbsa)
! Convert specific force types to generic OpenMM_Force so that we can
! add them to the OpenMM_System. ! Convert specific force types to generic OpenMM_Force so that we can
ix = OpenMM_System_addForce(system, transfer(nonbond, OpenMM_Force(0))) ! add them to the OpenMM_System.
ix = OpenMM_System_addForce(system, transfer(gbsa, OpenMM_Force(0))) ix = OpenMM_System_addForce(system, transfer(nonbond, OpenMM_Force(0)))
ix = OpenMM_System_addForce(system, transfer(gbsa, OpenMM_Force(0)))
! Specify dielectrics for GBSA implicit solvation.
call OpenMM_GBSAOBCForce_setSolventDielectric(gbsa, SolventDielectric) ! Specify dielectrics for GBSA implicit solvation.
call OpenMM_GBSAOBCForce_setSoluteDielectric(gbsa, SoluteDielectric) call OpenMM_GBSAOBCForce_setSolventDielectric(gbsa, SolventDielectric)
call OpenMM_GBSAOBCForce_setSoluteDielectric(gbsa, SoluteDielectric)
! Specify the atoms and their properties:
! (1) System needs to know the masses. ! Specify the atoms and their properties:
! (2) NonbondedForce needs charges,van der Waals properties (in MD units!). ! (1) System needs to know the masses.
! (3) GBSA needs charge, radius, and scale factor. ! (2) NonbondedForce needs charges,van der Waals properties (in MD units!).
! (4) Collect default positions for initializing the simulation later. ! (3) GBSA needs charge, radius, and scale factor.
call OpenMM_Vec3Array_create(initialPosInNm, NumAtoms) ! (4) Collect default positions for initializing the simulation later.
do n=1,NumAtoms call OpenMM_Vec3Array_create(initialPosInNm, NumAtoms)
ix = OpenMM_System_addParticle(system, atoms(n)%mass) do n=1,NumAtoms
ix = OpenMM_System_addParticle(system, atoms(n)%mass)
ix = OpenMM_NonbondedForce_addParticle(nonbond, &
atoms(n)%charge, & ix = OpenMM_NonbondedForce_addParticle(nonbond, &
atoms(n)%vdwRadiusInAng * OpenMM_NmPerAngstrom & atoms(n)%charge, &
* OpenMM_SigmaPerVdwRadius, & atoms(n)%vdwRadiusInAng * OpenMM_NmPerAngstrom &
atoms(n)%vdwEnergyInKcal * OpenMM_KJPerKcal) * OpenMM_SigmaPerVdwRadius, &
atoms(n)%vdwEnergyInKcal * OpenMM_KJPerKcal)
ix = OpenMM_GBSAOBCForce_addParticle(gbsa, &
atoms(n)%charge, & ix = OpenMM_GBSAOBCForce_addParticle(gbsa, &
atoms(n)%gbsaRadiusInAng * OpenMM_NmPerAngstrom, & atoms(n)%charge, &
atoms(n)%gbsaScaleFactor) atoms(n)%gbsaRadiusInAng * OpenMM_NmPerAngstrom, &
atoms(n)%gbsaScaleFactor)
! Sets initPos(n) = atoms(n)%initPos * nm/Angstrom.
call OpenMM_Vec3Array_setScaled(initialPosInNm, n, & ! Sets initPos(n) = atoms(n)%initPos * nm/Angstrom.
atoms(n)%initPosInAng, & call OpenMM_Vec3_scale(atoms(n)%initPosInAng, &
OpenMM_NmPerAngstrom) OpenMM_NmPerAngstrom, posInNm)
end do call OpenMM_Vec3Array_set(initialPosInNm, n, posInNm)
end do
! Choose an Integrator for advancing time, and a Context connecting the
! System with the Integrator for simulation. Let the Context choose the ! Choose an Integrator for advancing time, and a Context connecting the
! best available Platform. Initialize the configuration from the default ! System with the Integrator for simulation. Let the Context choose the
! positions we collected above. Initial velocities will be zero but could ! best available Platform. Initialize the configuration from the default
! have been set here. ! positions we collected above. Initial velocities will be zero but could
call OpenMM_LangevinIntegrator_create(langevin, & ! have been set here.
Temperature, FrictionInPerPs, & call OpenMM_LangevinIntegrator_create(langevin, &
StepSizeInFs * OpenMM_PsPerFs) Temperature, FrictionInPerPs, &
StepSizeInFs * OpenMM_PsPerFs)
! Convert LangevinIntegrator to generic Integrator type for this call.
call OpenMM_Context_create(context, system, & ! Convert LangevinIntegrator to generic Integrator type for this call.
transfer(langevin, OpenMM_Integrator(0))) call OpenMM_Context_create(context, system, &
call OpenMM_Context_setPositions(context, initialPosInNm) transfer(langevin, OpenMM_Integrator(0)))
call OpenMM_Context_setPositions(context, initialPosInNm)
! Get the platform name to return.
call OpenMM_Context_getPlatformName(context, platformName) ! Get the platform name to return.
call OpenMM_Context_getPlatform(context, platform)
! Put the System, Integrator, and Context in the RuntimeObjects call OpenMM_Platform_getName(platform, platformName)
! container and return an opaque reference to the container.
call OpenMM_RuntimeObjects_create(omm) ! Put the System, Integrator, and Context in the RuntimeObjects
call OpenMM_RuntimeObjects_setSystem(omm, system) ! container and return an opaque reference to the container.
call OpenMM_RuntimeObjects_setIntegrator(omm, & call OpenMM_RuntimeObjects_create(omm)
transfer(langevin, OpenMM_Integrator(0))) call OpenMM_RuntimeObjects_setSystem(omm, system)
call OpenMM_RuntimeObjects_setContext(omm, context) call OpenMM_RuntimeObjects_setIntegrator(omm, &
ommHandle = transfer(omm, ommHandle) transfer(langevin, OpenMM_Integrator(0)))
END SUBROUTINE call OpenMM_RuntimeObjects_setContext(omm, context)
ommHandle = transfer(omm, ommHandle)
END SUBROUTINE
!-------------------------------------------------------------------------------
! COPY STATE BACK TO CPU FROM OpenMM
!------------------------------------------------------------------------------- !-------------------------------------------------------------------------------
SUBROUTINE myGetOpenMMState(ommHandle, timeInPs, energyInKcal) ! COPY STATE BACK TO CPU FROM OpenMM
use OpenMM; use MyAtomInfo; implicit none !-------------------------------------------------------------------------------
integer*8, intent(in) :: ommHandle SUBROUTINE myGetOpenMMState(ommHandle, timeInPs, energyInKcal)
real*8, intent(out) :: timeInPs, energyInKcal use OpenMM; use MyAtomInfo; implicit none
integer*8, intent(in) :: ommHandle
type (OpenMM_State) state real*8, intent(out) :: timeInPs, energyInKcal
type (OpenMM_Vec3Array) posArrayInNm
integer infoMask, n type (OpenMM_State) state
type (OpenMM_Vec3Array) posArrayInNm
type (OpenMM_RuntimeObjects) omm integer infoMask, n
type (OpenMM_Context) context real*8 posInNm(3)
omm = transfer(ommHandle, omm) type (OpenMM_RuntimeObjects) omm
call OpenMM_RuntimeObjects_getContext(omm, context) type (OpenMM_Context) context
infoMask = OpenMM_State_Positions omm = transfer(ommHandle, omm)
if (WantEnergy) then call OpenMM_RuntimeObjects_getContext(omm, context)
infoMask = infoMask + OpenMM_State_Velocities ! for KE (cheap)
infoMask = infoMask + OpenMM_State_Energy ! for PE (very expensive) infoMask = OpenMM_State_Positions
end if if (WantEnergy) then
! Forces are also available (and cheap). infoMask = infoMask + OpenMM_State_Velocities ! for KE (cheap)
infoMask = infoMask + OpenMM_State_Energy ! for PE (very expensive)
! Don't forget to destroy this State when you're done with it. end if
call OpenMM_Context_createState(context, infoMask, state) ! Forces are also available (and cheap).
timeInPs = OpenMM_State_getTime(state) ! OpenMM time is in ps already.
! Don't forget to destroy this State when you're done with it.
! Positions are maintained as a Vec3Array inside the State. This will give call OpenMM_Context_getState(context, infoMask, state)
! us access, but don't destroy it yourself -- it will go away with the State. timeInPs = OpenMM_State_getTime(state) ! OpenMM time is in ps already.
call OpenMM_State_getPositions(state, posArrayInNm)
do n = 1, NumAtoms ! Positions are maintained as a Vec3Array inside the State. This will give
! Sets atoms(n)%pos = posArray(n) * Angstroms/nm. ! us access, but don't destroy it yourself -- it will go away with the State.
call OpenMM_Vec3Array_getScaled(posArrayInNm, n, OpenMM_AngstromsPerNm, & call OpenMM_State_getPositions(state, posArrayInNm)
atoms(n)%posInAng) do n = 1, NumAtoms
end do ! Sets atoms(n)%pos = posArray(n) * Angstroms/nm.
call OpenMM_Vec3Array_get(posArrayInNm, n, posInNm)
energyInKcal = 0 call OpenMM_Vec3_scale(posInNm, OpenMM_AngstromsPerNm, &
if (WantEnergy) then atoms(n)%posInAng)
energyInKcal = ( OpenMM_State_getPotentialEnergy(state) & end do
+ OpenMM_State_getKineticEnergy(state)) &
* OpenMM_KcalPerKJ energyInKcal = 0
end if if (WantEnergy) then
energyInKcal = ( OpenMM_State_getPotentialEnergy(state) &
! Clean up the State memory + OpenMM_State_getKineticEnergy(state)) &
call OpenMM_State_destroy(state) * OpenMM_KcalPerKJ
END SUBROUTINE end if
! Clean up the State memory
!------------------------------------------------------------------------------- call OpenMM_State_destroy(state)
! TAKE MULTIPLE STEPS USING OpenMM END SUBROUTINE
!-------------------------------------------------------------------------------
SUBROUTINE myStepWithOpenMM(ommHandle, numSteps)
use OpenMM; implicit none !-------------------------------------------------------------------------------
integer*8, intent(in) :: ommHandle ! TAKE MULTIPLE STEPS USING OpenMM
integer, intent(in) :: numSteps !-------------------------------------------------------------------------------
SUBROUTINE myStepWithOpenMM(ommHandle, numSteps)
type (OpenMM_RuntimeObjects) omm use OpenMM; implicit none
type (OpenMM_Integrator) integrator integer*8, intent(in) :: ommHandle
omm = transfer(ommHandle, omm) integer, intent(in) :: numSteps
call OpenMM_RuntimeObjects_getIntegrator(omm, integrator)
type (OpenMM_RuntimeObjects) omm
call OpenMM_Integrator_step(integrator, numSteps) type (OpenMM_Integrator) integrator
END SUBROUTINE omm = transfer(ommHandle, omm)
call OpenMM_RuntimeObjects_getIntegrator(omm, integrator)
!------------------------------------------------------------------------------- call OpenMM_Integrator_step(integrator, numSteps)
! DEALLOCATE ALL OpenMM OBJECTS END SUBROUTINE
!-------------------------------------------------------------------------------
SUBROUTINE myTerminateOpenMM(ommHandle)
use OpenMM; implicit none !-------------------------------------------------------------------------------
integer*8, intent(in) :: ommHandle ! DEALLOCATE ALL OpenMM OBJECTS
!-------------------------------------------------------------------------------
type (OpenMM_RuntimeObjects) omm SUBROUTINE myTerminateOpenMM(ommHandle)
omm = transfer(ommHandle, omm) use OpenMM; implicit none
integer*8, intent(in) :: ommHandle
call OpenMM_RuntimeObjects_destroy(omm)
END SUBROUTINE type (OpenMM_RuntimeObjects) omm
omm = transfer(ommHandle, omm)
call OpenMM_RuntimeObjects_destroy(omm)
END SUBROUTINE
examples/NMakefile
View file @ c6c034ba
...@@ -59,26 +59,30 @@ fortran: $(ALL_F95_EXAMPLES) ...@@ -59,26 +59,30 @@ fortran: $(ALL_F95_EXAMPLES)
HelloArgon HelloSodiumChloride HelloEthane HelloWaterBox: HelloArgon HelloSodiumChloride HelloEthane HelloWaterBox:
$(CC) $(CFLAGS) -I$(INCLUDE_DIR) $*.cpp /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe $(CC) $(CFLAGS) -I$(INCLUDE_DIR) $*.cpp /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe
HelloArgonInC: HelloArgonInC.c OpenMM_CWrapper.obj HelloArgonInC: HelloArgonInC.c OpenMMCWrapper.obj
$(CC) $(CFLAGS) -I. $*.c OpenMM_CWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe $(CC) $(CFLAGS) -I. $*.c OpenMMCWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe
HelloSodiumChlorideInC: HelloSodiumChlorideInC.c OpenMM_CWrapper.obj HelloSodiumChlorideInC: HelloSodiumChlorideInC.c OpenMMCWrapper.obj
$(CC) $(CFLAGS) -I. $*.c OpenMM_CWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe $(CC) $(CFLAGS) -I. $*.c OpenMMCWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe
HelloArgonInFortran: HelloArgonInFortran.f90 openmm.mod OpenMM_CWrapper.obj HelloArgonInFortran: HelloArgonInFortran.f90 openmm.mod OpenMMFortranWrapper.obj OpenMMCWrapper.obj
$(FC) $(FFLAGS) $*.f90 OpenMM_CWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe $(FC) $(FFLAGS) $*.f90 OpenMMFortranWrapper.obj OpenMMCWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe
HelloSodiumChlorideInFortran: HelloSodiumChlorideInFortran.f90 openmm.mod OpenMM_CWrapper.obj HelloSodiumChlorideInFortran: HelloSodiumChlorideInFortran.f90 openmm.mod OpenMMFortranWrapper.obj OpenMMCWrapper.obj
$(FC) $(FFLAGS) $*.f90 OpenMM_CWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe $(FC) $(FFLAGS) $*.f90 OpenMMFortranWrapper.obj OpenMMCWrapper.obj /link /libpath:$(LIB_DIR) $(LIBS) /out:$*.exe
# Build C Wrappers (Fortran depends on this too) # Build C Wrappers (Fortran depends on this too)
OpenMM_CWrapper.obj: OpenMM_CWrapper.cpp OpenMMCWrapper.obj: OpenMMCWrapper.cpp
$(CC) $(CFLAGS) -c -I. -I$(INCLUDE_DIR) OpenMM_CWrapper.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 # Build Fortran 95 Module file
openmm.mod: OpenMM_Module.f90 openmm.mod: OpenMMFortranModule.f90
$(FC) -c $(FFLAGS) OpenMM_Module.f90 $(FC) -c $(FFLAGS) OpenMMFortranModule.f90
clean : clean :
del *.mod *.obj *.exe *.pdb *.exe.manifest 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