Add access to position/velocity in Particle

Author: Guillaume Fraux

src/lib.rs

@@ -6,10 +6,10 @@ extern crate lumol;
 mod macros;
 mod systems;
 
+py_exception!(lumol, LumolError);
+
 py_module_initializer!(lumol, initlumol, PyInit_lumol, |py, m| {
     try!(m.add(py, "__doc__", "Modern and extensible molecular simulation engine"));
-
     try!(systems::register(py, m));
-
     Ok(())
 });

src/macros.rs

@@ -8,20 +8,39 @@ macro_rules! create_instance {
 
 macro_rules! py_run_with {
     ($py: ident, $obj: ident; $($code: expr),+) => ({
+        const ASSERT_RAISES_PY: &'static str = "
+def assert_raises(callable, *args, **kwargs):
+    throw = True
+    try:
+        callable(*args, **kwargs)
+        throw = False
+    except LumolError:
+        pass
+    assert throw
+";
         use cpython::PyDict;
-        let dict = PyDict::new($py);
-        dict.set_item($py, stringify!($obj), $obj).unwrap();
-        py_run!($py, dict, $($code),+);
+        let locals = PyDict::new($py);
+        locals.set_item($py, stringify!($obj), $obj).unwrap();
+
+        let globals = PyDict::new($py);
+        let error = $py.get_type::<::LumolError>();
+        globals.set_item($py, "LumolError", error).unwrap();
+
+        py_run!($py, globals, locals, ASSERT_RAISES_PY);
+        py_run!($py, globals, locals, $($code),+);
     });
+    ($py: ident, $obj: ident; $($code: expr),+,) => (
+        py_run_with!($py, $obj; $($code),+);
+    )
 }
 
 macro_rules! py_run {
-    ($py: ident, $dict: ident, $code: expr) => ({
-         $py.run($code, None, Some(&$dict)).expect($code);
+    ($py: ident, $globals: ident, $locals: ident, $code: expr) => ({
+         $py.run($code, Some(&$globals), Some(&$locals)).expect($code);
     });
-    ($py: ident, $dict: ident, $code: expr, $($tail: expr),+) => ({
-         $py.run($code, None, Some(&$dict)).expect($code);
-         py_run!($py, $dict, $($tail),+);
+    ($py: ident, $globals: ident, $locals: ident, $code: expr, $($tail: expr),+) => ({
+         $py.run($code, Some(&$globals), Some(&$locals)).expect($code);
+         py_run!($py, $globals, $locals, $($tail),+);
     });
 }
 
@@ -32,3 +51,9 @@ macro_rules! register {
         }
     );
 }
+
+macro_rules! raise {
+    ($py: ident, $args: expr) => ({
+        Err(PyErr::new::<LumolError, _>($py, $args))
+    });
+}

src/systems/particle.rs

@@ -1,7 +1,10 @@
-use cpython::{PyObject, PyResult};
+use cpython::{PyObject, PyErr, PyResult, PyTuple, ToPyObject, PythonObject};
 use lumol;
+use lumol::Vector3D;
 use std::cell::RefCell;
 
+use LumolError;
+
 register!(|py, m| {
     try!(m.add_class::<Particle>(py));
     Ok(())
@@ -39,6 +42,72 @@ py_class!(class Particle |py| {
         self.particle(py).borrow_mut().charge = charge;
         Ok(py.None())
     }
+
+    def position(&self) -> PyResult<PyTuple> {
+        let position = &self.particle(py).borrow().position;
+
+        let x = position[0].to_py_object(py).into_object();
+        let y = position[1].to_py_object(py).into_object();
+        let z = position[2].to_py_object(py).into_object();
+
+        Ok(PyTuple::new(py, &[x, y, z]))
+    }
+
+    def set_position(&self, position: &PyTuple) -> PyResult<PyObject> {
+        if position.len(py) != 3 {
+            return raise!(py, format!(
+                "Wrong size for the position: should be a 3-dimmensional \
+                tuple, but contains {} elements", position.len(py)
+            ));
+        }
+
+        let x = try!(position.get_item(py, 0).extract::<f64>(py).or(
+            raise!(py, "Position elements should be numbers"))
+        );
+        let y = try!(position.get_item(py, 1).extract::<f64>(py).or(
+            raise!(py, "Position elements should be numbers"))
+        );
+        let z = try!(position.get_item(py, 2).extract::<f64>(py).or(
+            raise!(py, "Position elements should be numbers"))
+        );
+
+        self.particle(py).borrow_mut().position = Vector3D::new(x, y, z);
+
+        Ok(py.None())
+    }
+
+    def velocity(&self) -> PyResult<PyTuple> {
+        let velocity = &self.particle(py).borrow().velocity;
+
+        let x = velocity[0].to_py_object(py).into_object();
+        let y = velocity[1].to_py_object(py).into_object();
+        let z = velocity[2].to_py_object(py).into_object();
+
+        Ok(PyTuple::new(py, &[x, y, z]))
+    }
+
+    def set_velocity(&self, velocity: &PyTuple) -> PyResult<PyObject> {
+        if velocity.len(py) != 3 {
+            return raise!(py, format!(
+                "Wrong size for the velocity: should be a 3-dimmensional \
+                tuple, but contains {} elements", velocity.len(py)
+            ));
+        }
+
+        let x = try!(velocity.get_item(py, 0).extract::<f64>(py).or(
+            raise!(py, "Velocity elements should be numbers"))
+        );
+        let y = try!(velocity.get_item(py, 1).extract::<f64>(py).or(
+            raise!(py, "Velocity elements should be numbers"))
+        );
+        let z = try!(velocity.get_item(py, 2).extract::<f64>(py).or(
+            raise!(py, "Velocity elements should be numbers"))
+        );
+
+        self.particle(py).borrow_mut().velocity = Vector3D::new(x, y, z);
+
+        Ok(py.None())
+    }
 });
 
 #[cfg(test)]
@@ -120,5 +189,41 @@ mod tests {
                 "assert particle.charge() == 2"
             );
         }
+
+        #[test]
+        fn position() {
+            let gil = Python::acquire_gil();
+            let py = gil.python();
+            let particle = create_instance!(py, Particle, ("He",));
+
+            py_run_with!(py, particle;
+                "assert particle.position() == (0.0, 0.0, 0.0)",
+                "particle.set_position((1, 2, 3))",
+                "assert particle.position() == (1, 2, 3)",
+                "assert_raises(particle.set_position, (2, 3))",
+                "assert_raises(particle.set_position, (1, 2, 3, 4))",
+                "assert_raises(particle.set_position, ('1', 2, 3))",
+                "assert_raises(particle.set_position, (1, '2', 3))",
+                "assert_raises(particle.set_position, (1, 2, '3'))",
+            );
+        }
+
+        #[test]
+        fn velocity() {
+            let gil = Python::acquire_gil();
+            let py = gil.python();
+            let particle = create_instance!(py, Particle, ("He",));
+
+            py_run_with!(py, particle;
+                "assert particle.velocity() == (0.0, 0.0, 0.0)",
+                "particle.set_velocity((1, 2, 3))",
+                "assert particle.velocity() == (1, 2, 3)",
+                "assert_raises(particle.set_velocity, (2, 3))",
+                "assert_raises(particle.set_velocity, (1, 2, 3, 4))",
+                "assert_raises(particle.set_velocity, ('1', 2, 3))",
+                "assert_raises(particle.set_velocity, (1, '2', 3))",
+                "assert_raises(particle.set_velocity, (1, 2, '3'))",
+            );
+        }
     }
 }