Merge pull request #1094 from rmcgibbo/rmcgibbo-patch-2

Assorted windows / appveyor fixes. Mostly cosmetic.

.travis.yml

@@ -41,11 +41,11 @@ script:
   - # Run the testInstallation script
   - python -m simtk.testInstallation
   - # run all of the tests, making sure failures at this stage don't cause travis failures
-  - ctest -j2 -V || true
+  - ctest -j2 || true
   - # get a list of all of the failed tests into this stupid ctest format
   - python -c 'fn = "Testing/Temporary/LastTestsFailed.log"; import os; os.path.exists(fn) or exit(0); l = [line.split(":")[0] for line in open(fn)]; triplets = zip(l, l, [","]*len(l)); print "".join(",".join(t) for t in triplets)' > FailedTests.log
   - # rerun all of the failed tests
-  - if [ -s FailedTests.log ]; then ctest -V -I FailedTests.log; fi;
+  - if [ -s Testing/Temporary/LastTestsFailed.log ]; then ctest -I FailedTests.log; fi;
   - # run the python tests too
   - cd python/tests
   - pip install nose

CMakeLists.txt

 #---------------------------------------------------
-# OpenMM 
+# OpenMM
 #
 # Creates OpenMM library.
 #
@@ -43,11 +43,11 @@ SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake_modules")
 # (cmake 2.4.7 is OK)
 if(COMMAND cmake_policy)
     if(CMAKE_MAJOR_VERSION GREATER 2 OR CMAKE_MINOR_VERSION GREATER 5)
-        cmake_policy(SET CMP0003 NEW) 
-        cmake_policy(SET CMP0005 NEW) 
+        cmake_policy(SET CMP0003 NEW)
+        cmake_policy(SET CMP0005 NEW)
     endif(CMAKE_MAJOR_VERSION GREATER 2 OR CMAKE_MINOR_VERSION GREATER 5)
     if(CMAKE_MAJOR_VERSION GREATER 2 OR CMAKE_MINOR_VERSION GREATER 6 OR CMAKE_PATCH_VERSION GREATER 2)
-        cmake_policy(SET CMP0011 NEW) 
+        cmake_policy(SET CMP0011 NEW)
     endif(CMAKE_MAJOR_VERSION GREATER 2 OR CMAKE_MINOR_VERSION GREATER 6 OR CMAKE_PATCH_VERSION GREATER 2)
 endif(COMMAND cmake_policy)
 
@@ -70,7 +70,7 @@ ENDIF (ANDROID)
 # It seems that on linux and mac, everything is trying to be installed in /usr/local/openmm
 # But if every install target is prefixed with /openmm/, on Windows the install files
 # end up in C:/Program Files/OpenMM/openmm/ which is ugly.
-# Better to set CMAKE_INSTALL_PREFIX to /usr/local/openmm and leave /openmm/ off the 
+# Better to set CMAKE_INSTALL_PREFIX to /usr/local/openmm and leave /openmm/ off the
 # install target names.  Plus, the user now has the opportunity to install into /usr/local/
 # if she so chooses.  --cmb
 IF(${CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT})
@@ -122,7 +122,10 @@ ELSE (APPLE AND (NOT PNACL))
     IF (MSVC OR ANDROID OR PNACL)
         SET(EXTRA_COMPILE_FLAGS)
         IF (MSVC)
+            # Use warning level 2, not whatever warning level CMake picked.
             STRING(REGEX REPLACE "/W[0-4]" "/W2" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            # Explicitly suppress warnings 4305 and 4244.
+            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4305 /wd4244")
         ENDIF (MSVC)
     ELSE (MSVC OR ANDROID OR PNACL)
         SET(EXTRA_COMPILE_FLAGS "-msse2")
@@ -142,7 +145,7 @@ IF (NOT CMAKE_CXX_FLAGS_RELEASE)
         SET(CMAKE_CXX_FLAGS_RELEASE "-mfloat-abi=softfp -march=armv7-a -mfpu=neon -funsafe-math-optimizations -O3 -DNDEBUG" CACHE STRING
         "To use when CMAKE_BUILD_TYPE=Release" FORCE)
     ELSE (ANDROID)
-        SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG" CACHE STRING 
+        SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG" CACHE STRING
         "To use when CMAKE_BUILD_TYPE=Release" FORCE)
     ENDIF (ANDROID)
 ENDIF (NOT CMAKE_CXX_FLAGS_RELEASE)
@@ -205,11 +208,11 @@ SET(STATIC_TARGET ${OPENMM_LIBRARY_NAME}_static)
 ## If no one says otherwise, change the executable path to drop into the same binary
 ## location as the DLLs so that the test cases will use the just-build DLLs.
 IF(NOT EXECUTABLE_OUTPUT_PATH)
-  SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR} 
+  SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}
       CACHE INTERNAL "Single output directory for building all executables.")
 ENDIF(NOT EXECUTABLE_OUTPUT_PATH)
 IF(NOT LIBRARY_OUTPUT_PATH)
-  SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR} 
+  SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}
       CACHE INTERNAL "Single output directory for building all libraries.")
 ENDIF(NOT LIBRARY_OUTPUT_PATH)
 SET(${PROJECT_NAME}_EXECUTABLE_DIR ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR})
@@ -224,7 +227,7 @@ SET(API_INCLUDE_DIRS) # start empty
 FOREACH(subdir ${OPENMM_SOURCE_SUBDIRS})
     # append
     SET(API_INCLUDE_DIRS ${API_INCLUDE_DIRS}
-                         ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/include 
+                         ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/include
                          ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/include/openmm
                          ${CMAKE_CURRENT_SOURCE_DIR}/${subdir}/include/openmm/internal)
 ENDFOREACH(subdir)
@@ -364,7 +367,7 @@ IF(CUDA_FOUND)
     SET(OPENMM_BUILD_CUDA_LIB ON CACHE BOOL "Build OpenMMCuda library for Nvidia GPUs")
 
     # I wish I was not hardcoding /MD here
-    # Avoid strange windows link error with cuda free energy 
+    # Avoid strange windows link error with cuda free energy
     # plugin by specifying /MD to CUDA_NVCC_FLAGS
     MARK_AS_ADVANCED(CLEAR CUDA_NVCC_FLAGS)
     IF(MSVC)
@@ -380,7 +383,7 @@ IF(CUDA_FOUND)
             if(CUDA_NVCC_FLAGS)
                 set(new_flags "${CUDA_NVCC_FLAGS};${new_flags}")
             endif(CUDA_NVCC_FLAGS)
-            SET(CUDA_NVCC_FLAGS "${new_flags}" 
+            SET(CUDA_NVCC_FLAGS "${new_flags}"
                 CACHE STRING "Semicolon delimit multiple arguments" FORCE)
         ENDIF(NOT HAS_NVCC_FLAG)
     ENDIF(MSVC)

appveyor.yml

@@ -32,14 +32,16 @@ install:
 # Run the build
   - jom install
   - jom PythonInstall
-  
+
 build: false
 test_script:
-  - ctest && exit 0
-  - python -c "import os; fn = os.path.join('Testing', 'Temporary', 'LastTestsFailed.log'); os.path.exists(fn) or exit(0); l = [line.split(':')[0] for line in open(fn)]; triplets = zip(l, l, [',']*len(l)); print(''.join(','.join(t) for t in triplets))" > FailedTests.log
+  - ctest || exit 0
+  - python -c "import os; fn = os.path.join('Testing', 'Temporary', 'LastTestsFailed.log'); os.path.exists(fn) or exit(0); failed = [line.split(':')[0] for line in open(fn)]; print(','.join(x+','+x for x in failed))" > FailedTests.log
   - ps: >
-     If (Test-Path "FailedTests.log") {
-         ctest -V -I FailedTests.log
+     If (Test-Path "Testing\\Temporary\\LastTestsFailed.log") {
+         cat Testing\\Temporary\\LastTestsFailed.log
+         cat FailedTests.log
+         ctest -I FailedTests.log
      }
   - cd python\tests
   - nosetests -vv --processes=-1 --process-timeout=200

wrappers/python/tests/TestAmberInpcrdFile.py

@@ -4,14 +4,21 @@ from simtk.openmm.app import *
 from simtk.openmm import *
 from simtk.unit import *
 import simtk.openmm.app.element as elem
+try:
+    from scipy.io import netcdf
+    SCIPY_IMPORT_FAILED = False
+except:
+    SCIPY_IMPORT_FAILED = True
+
 
 def compareByElement(array1, array2, cmp):
     for x, y in zip(array1, array2):
         cmp(x, y)
 
+
 class TestAmberInpcrdFile(unittest.TestCase):
     """Test the Amber inpcrd file parser"""
- 
+
     def test_CrdVelBox(self):
         """ Test parsing ASCII restarts with crds, vels, and box """
         cmp = self.assertAlmostEqual
@@ -24,24 +31,21 @@ class TestAmberInpcrdFile(unittest.TestCase):
         compareByElement(inpcrd.boxVectors[0].value_in_unit(angstroms),
                          [30.2642725, 0.0, 0.0], cmp)
 
+    @unittest.skipIf(SCIPY_IMPORT_FAILED, "Scipy is not installed")
     def test_NetCDF(self):
         """ Test NetCDF restart file parsing """
         cmp = self.assertAlmostEqual
-        try:
-            from scipy.io import netcdf
-        except ImportError:
-            print('Not testing NetCDF file parser... scipy cannot be found')
-        else:
-            inpcrd = AmberInpcrdFile('systems/amber.ncrst')
-            self.assertEqual(len(inpcrd.positions), 2101)
-            compareByElement(inpcrd.positions[0].value_in_unit(angstroms),
-                             [6.82122492718229, 6.6276250662042, -8.51668999892245],
-                             cmp)
-            compareByElement(inpcrd.velocities[-1].value_in_unit(angstroms/picosecond),
-                             [0.349702202733541*20.455, 0.391525333168534*20.455,
-                              0.417941679767662*20.455], cmp)
-            self.assertAlmostEqual(inpcrd.boxVectors[0][0].value_in_unit(angstroms),
-                                   30.2642725, places=6)
+
+        inpcrd = AmberInpcrdFile('systems/amber.ncrst')
+        self.assertEqual(len(inpcrd.positions), 2101)
+        compareByElement(inpcrd.positions[0].value_in_unit(angstroms),
+                         [6.82122492718229, 6.6276250662042, -8.51668999892245],
+                         cmp)
+        compareByElement(inpcrd.velocities[-1].value_in_unit(angstroms/picosecond),
+                         [0.349702202733541*20.455, 0.391525333168534*20.455,
+                          0.417941679767662*20.455], cmp)
+        self.assertAlmostEqual(inpcrd.boxVectors[0][0].value_in_unit(angstroms),
+                               30.2642725, places=6)
 
     def test_CrdBox(self):
         """ Test parsing ASCII restarts with only crds and box """

wrappers/python/tests/TestCheckpointReporter.py

 import os
 import unittest
 import tempfile
-import numpy as np
 from simtk.openmm import app
 import simtk.openmm as mm
 from simtk import unit
@@ -24,17 +23,19 @@ class TestCheckpointReporter(unittest.TestCase):
         self.simulation.step(1)
 
         # get the current positions
-        positions = self.simulation.context.getState(getPositions=True).getPositions(asNumpy=True)._value
+        positions = self.simulation.context.getState(getPositions=True).getPositions()
+
         # now set the positions into junk...
-        self.simulation.context.setPositions(np.random.random(positions.shape))
+        self.simulation.context.setPositions([mm.Vec3(0, 0, 0)] * len(positions))
+
         # then reload the right positions from the checkpoint
         file.close()
         with open(file.name, 'rb') as f:
             self.simulation.context.loadCheckpoint(f.read())
         os.unlink(file.name)
 
-        newPositions = self.simulation.context.getState(getPositions=True).getPositions(asNumpy=True)._value
-        np.testing.assert_array_equal(positions, newPositions)
+        newPositions = self.simulation.context.getState(getPositions=True).getPositions()
+        self.assertSequenceEqual(positions, newPositions)
 
 if __name__ == '__main__':
     unittest.main()

wrappers/python/tests/TestNumpyCompatibility.py

 import unittest
-import numpy as np
-
 from simtk.openmm import app
 import simtk.openmm as mm
 from simtk import unit
+try:
+    import numpy as np
+    NUMPY_IMPORT_FAILED = False
+except ImportError:
+    NUMPY_IMPORT_FAILED = True
+
 
+@unittest.skipIf(NUMPY_IMPORT_FAILED, 'Numpy is not installed')
 class TestNumpyCompatibility(unittest.TestCase):
-    
+
     def setUp(self):
         prmtop = app.AmberPrmtopFile('systems/water-box-216.prmtop')
-    
-        system = prmtop.createSystem(nonbondedMethod=app.PME, 
+
+        system = prmtop.createSystem(nonbondedMethod=app.PME,
                                          nonbondedCutoff=0.9*unit.nanometers,
-                                         constraints=app.HBonds, rigidWater=True, 
+                                         constraints=app.HBonds, rigidWater=True,
                                          ewaldErrorTolerance=0.0005)
-        integrator = mm.LangevinIntegrator(300*unit.kelvin, 1.0/unit.picoseconds, 
+        integrator = mm.LangevinIntegrator(300*unit.kelvin, 1.0/unit.picoseconds,
                                            2.0*unit.femtoseconds)
         self.simulation = app.Simulation(prmtop.topology, system, integrator,
                                     mm.Platform.getPlatformByName('Reference'))
-    
-    
+
+
     def test_setPositions(self):
         n_particles = self.simulation.context.getSystem().getNumParticles()
         input = np.random.randn(n_particles, 3)
         self.simulation.context.setPositions(input)
         output = self.simulation.context.getState(getPositions=True).getPositions(asNumpy=True)
-    
+
         np.testing.assert_array_almost_equal(input, output)
-    
+
     def test_setPositions_units(self):
         n_particles = self.simulation.context.getSystem().getNumParticles()
         input = unit.Quantity(np.random.randn(n_particles, 3), unit.angstroms)
         self.simulation.context.setPositions(input)
         output = self.simulation.context.getState(getPositions=True).getPositions(asNumpy=True)
-    
+
         np.testing.assert_array_almost_equal(input.value_in_unit(unit.nanometers), output.value_in_unit(unit.nanometers))
-    
-    
+
+
     def test_setVelocities(self):
         n_particles = self.simulation.context.getSystem().getNumParticles()
         input = np.random.randn(n_particles, 3)
         self.simulation.context.setVelocities(input)
         output = self.simulation.context.getState(getVelocities=True).getVelocities(asNumpy=True)
-    
+
         np.testing.assert_array_almost_equal(input, output)
-    
+
     def test_setVelocities_units(self):
         n_particles = self.simulation.context.getSystem().getNumParticles()
         input = unit.Quantity(np.random.randn(n_particles, 3), unit.angstroms / unit.femtoseconds)
         self.simulation.context.setVelocities(input)
         output = self.simulation.context.getState(getVelocities=True).getVelocities(asNumpy=True)
-    
+
         np.testing.assert_array_almost_equal(input.value_in_unit(unit.angstroms / unit.femtoseconds),
                                              output.value_in_unit(unit.angstroms / unit.femtoseconds))
-    
-    
+
+
     def test_tabulatedFunction(self):
         f = mm.CustomNonbondedForce('g(r)')
-    
+
         r = np.linspace(0,10)
         g_of_r = np.sin(r)
-    
-        indx = f.addFunction('g', g_of_r, np.min(r), np.max(r)) 
-    
+
+        indx = f.addFunction('g', g_of_r, np.min(r), np.max(r))
+
         name, g_of_r_out, min_r_out, max_r_out = f.getFunctionParameters(indx)
-    
+
         np.testing.assert_array_almost_equal(g_of_r, np.asarray(g_of_r_out))
         assert min_r_out == np.min(r)
         assert max_r_out == np.max(r)
-    
+
     def test_CMAP(self):
         f = mm.CMAPTorsionForce()
         energy = np.random.randn(10*10)
@@ -76,10 +81,12 @@ class TestNumpyCompatibility(unittest.TestCase):
         size, energy_out = f.getMapParameters(0)
         energy_out = energy_out.value_in_unit_system(unit.md_unit_system)
 
-    
+
         self.assertEqual(size, 10)
         np.testing.assert_array_almost_equal(energy, np.asarray(energy_out))
 
+
+@unittest.skipIf(NUMPY_IMPORT_FAILED, 'Numpy is not installed')
 class TestNumpyUnits(unittest.TestCase):
 
     def setUp(self):