Added Python wrapper around top level classes.

4 files changed, 254 insertions, 11 deletions

diff --git a/Python/classwrapper.i b/Python/classwrapper.i
new file mode 100644
index 000000000..7cbf2246a
--- /dev/null
+++ b/Python/classwrapper.i
@@ -0,0 +1,230 @@
+%{
+
+#include <iostream>
+#include <ostream>
+#include <fstream>
+#include <sstream>
+#include <stdio.h>
+
+#include <Array.H>
+#include <IntVect.H>
+
+#include <Particles.H>
+
+#include <Box.H>
+#include <FArrayBox.H>
+#include <BoxArray.H>
+#include <MultiFab.H>
+#include <Geometry.H>
+
+#include <WarpX.H>
+
+%}
+
+%inline %{
+  std::ifstream & open_ifstream(const char *filename) {
+    std::ifstream *infile = new std::ifstream(filename);
+    return *infile; 
+  } 
+%}
+
+%inline %{
+  std::ofstream & open_ofstream(const char *filename) {
+    std::ofstream *outfile = new std::ofstream(filename);
+    return *outfile;
+  }
+%}
+
+%inline %{
+  void close_ofstream(std::ofstream& str) {
+    str.close();
+  }
+%}
+
+%inline %{
+  void close_ifstream(std::ifstream & str) {
+    str.close();
+  }
+%}
+
+%include <std_string.i>
+%rename(__str__) display;
+
+typedef double Real;
+
+%include "../../BoxLib/Src/C_BaseLib/Array.H"
+
+%extend Array {
+    T& __getitem__ (size_t i)
+    {
+        BL_ASSERT(i >= 0);
+        BL_ASSERT(i < self->size());
+        return self->std::vector<T>::operator[](i);
+    }
+
+    //
+    // Same as above, except acts on const Array's.
+    //
+    const T& __getitem__ (size_t i) const
+    {
+        BL_ASSERT(i >= 0);
+        BL_ASSERT(i < self->size());
+        return self->std::vector<T>::operator[](i);
+    }
+}
+
+%template(arrayReal) Array<Real>;
+%template(arrayInt) Array<int>;
+%template(arrayGeometry) Array<Geometry>;
+
+%extend Array<Real> {
+    PyObject *get_real() {
+      PyObject *arr = 0;
+      npy_intp dims[1];
+      dims[0] = self->std::vector<Real>::size();
+      arr = PyArray_NewFromDescr(&PyArray_Type,
+                                 PyArray_DescrFromType(NPY_DOUBLE), 1, dims, NULL,
+                                 self->dataPtr(), NPY_FORTRANORDER|NPY_ARRAY_WRITEABLE, NULL);
+      Py_INCREF(arr);
+      return arr;
+    }
+}
+%extend Array<int> {
+    PyObject *get_int() {
+      PyObject *arr = 0;
+      npy_intp dims[1];
+      dims[0] = self->std::vector<int>::size();
+      arr = PyArray_NewFromDescr(&PyArray_Type,
+                                 PyArray_DescrFromType(NPY_INT), 1, dims, NULL,
+                                 self->dataPtr(), NPY_FORTRANORDER|NPY_ARRAY_WRITEABLE, NULL);
+      Py_INCREF(arr);
+      return arr;
+    }
+}
+
+// Note that IntVect.H cannot be directly included since swig cannot parse the line setting up "const int* getVect".
+//%include "../../BoxLib/Src/C_BaseLib/IntVect.H"
+class IntVect {
+public:
+
+    IntVect(int i, int j, int k);
+    IntVect(const IntVect& rhs);
+
+    IntVect& shift(int coord, int s);
+
+    // static functions
+    static const IntVect& TheZeroVector();
+    static const IntVect& TheUnitVector();
+    static const IntVect& TheNodeVector();
+    static const IntVect& TheCellVector();
+};
+
+%extend IntVect {
+    //void writeOn(std::ofstream *os){
+    //    *os << *self;
+    //}
+    //void read(std::ifstream* ifs){
+    //    *ifs >> *self;
+    //}
+    int __getitem__(int index){
+        if (index < 0 || index >= BL_SPACEDIM) {
+          // SWIG_SetErrorMsg(PyExc_IndexError,"Index out of bounds\n");
+          return 0;
+          }
+        return (*self)[index];
+    }
+    int __len__() volatile { return BL_SPACEDIM; }
+    void __setitem__(int index,int val){
+        if (index < 0 || index >= BL_SPACEDIM) {
+          //SWIG_SetErrorMsg(PyExc_IndexError,"Index out of bounds\n");
+         } else {
+          (*self).setVal(index,val);
+        }
+    }
+    int __cmp__(const IntVect* other){
+        if( (*self) == (*other) ) {
+            return 0;
+        }
+        if( (*self)  <= (*other) ) {
+            return -1;
+        }
+        return 1;
+    }
+    PyObject *get() {
+      PyObject *arr = 0;
+      npy_intp dims[1];
+      dims[0] = BL_SPACEDIM;
+      arr = PyArray_NewFromDescr(&PyArray_Type,
+                                 PyArray_DescrFromType(NPY_INT), 1, dims, NULL,
+                                 self->getVect(), NPY_FORTRANORDER|NPY_ARRAY_WRITEABLE, NULL);
+      Py_INCREF(arr);
+      return arr;
+    }
+
+    //std::string display() {
+    //    std::ostringstream str;
+    //        str << *self;
+    //    return str.str();
+    //}
+}
+
+//%include "../../BoxLib/Src/C_BaseLib/Box.H"
+//%include "../../BoxLib/Src/C_BaseLib/FArrayBox.H"
+//%include "../../BoxLib/Src/C_BaseLib/BoxArray.H"
+//%include "../../BoxLib/Src/C_BaseLib/MultiFab.H"
+
+//#if (BL_SPACEDIM > 2)
+%ignore GetDLogA;
+//#endif
+
+%include "../../BoxLib/Src/C_BaseLib/Geometry.H"
+
+%template(arrayBoxArray) Array<BoxArray>;
+
+%include "../../BoxLib/Src/C_ParticleLib/Particles.H"
+
+//%template("WarpXParticleBase") Particle<PIdx::nattribs,0>;
+%template("WarpXParticleContainerBase") ParticleContainer<PIdx::nattribs,0,std::vector<Particle<PIdx::nattribs,0> > >;
+
+%ignore GetChargeDensity;
+
+%include "../Source/ParticleContainer.H"
+%include "../Source/WarpXParticleContainer.H"
+
+%extend WarpXParticleContainer {
+    PyObject * getLocations() {
+        Array<Real> result(0);
+        self->GetParticleLocations(result);
+        npy_intp dims[2] = {BL_SPACEDIM, self->TotalNumberOfParticles()};
+        PyObject *arr = PyArray_NewFromDescr(&PyArray_Type,
+                                             PyArray_DescrFromType(NPY_DOUBLE), 2, dims, NULL,
+                                             result.dataPtr(), NPY_ARRAY_F_CONTIGUOUS|NPY_ARRAY_WRITEABLE, NULL);
+        Py_INCREF(arr);
+        return arr;
+    } 
+    PyObject * getData(int start_comp, int num_comp) {
+        Array<Real> result(0);
+        self->GetParticleData(result, start_comp, num_comp);
+        npy_intp dims[2] = {num_comp, self->TotalNumberOfParticles()};
+        PyObject *arr = PyArray_NewFromDescr(&PyArray_Type,
+                                             PyArray_DescrFromType(NPY_DOUBLE), 2, dims, NULL,
+                                             result.dataPtr(), NPY_ARRAY_F_CONTIGUOUS|NPY_ARRAY_WRITEABLE, NULL);
+        Py_INCREF(arr);
+        return arr;
+    }
+    PyObject * getAllData() {
+        int num_comp = PIdx::nattribs;
+        Array<Real> result(0);
+        self->GetParticleData(result, 0, num_comp);
+        npy_intp dims[2] = {num_comp, self->TotalNumberOfParticles()};
+        PyObject *arr = PyArray_NewFromDescr(&PyArray_Type,
+                                             PyArray_DescrFromType(NPY_DOUBLE), 2, dims, NULL,
+                                             result.dataPtr(), NPY_ARRAY_F_CONTIGUOUS|NPY_ARRAY_WRITEABLE, NULL);
+        Py_INCREF(arr);
+        return arr;
+    }
+};
+
+%include "../../BoxLib/Src/C_AmrCoreLib/AmrCore.H"
+%include "../Source/WarpX.H"
+
diff --git a/Python/pywarpx/WarpX.py b/Python/pywarpx/WarpX.py
index 8b9ecefe5..976d94c74 100644
--- a/Python/pywarpx/WarpX.py
+++ b/Python/pywarpx/WarpX.py
@@ -4,21 +4,21 @@ from . import warpxC
 class WarpX(Bucket):
 
     def init(self):
-        warpxC.warpx_init()
+        self.warpx = warpxC.WarpX.GetInstance()
+        self.warpx.InitData()
 
-    def evolve(self, nsteps=None):
-        if nsteps is None:
-            warpxC.warpx_evolve()
-        else:
-            warpxC.warpx_evolve(nsteps)
+    def evolve(self, nsteps=-1):
+        self.warpx.Evolve(nsteps)
 
     def finalize(self):
-        warpxC.warpx_finalize()
+        warpxC.WarpX.ResetInstance()
 
     def getProbLo(self, direction):
-        return warpxC.warpx_getProbLo(direction)
+        return self.warpx.Geom()[0].ProbLo(direction)
+        #return warpxC.warpx_getProbLo(direction)
 
     def getProbHi(self, direction):
-        return warpxC.warpx_getProbHi(direction)
+        return self.warpx.Geom()[0].ProbHi(direction)
+        #return warpxC.warpx_getProbHi(direction)
 
 warpx = WarpX('warpx')
diff --git a/Python/setup.py b/Python/setup.py
index c1d2855a4..58f77b8da 100644
--- a/Python/setup.py
+++ b/Python/setup.py
@@ -4,6 +4,7 @@
 setup.py file for WarpX
 """
 
+import os
 from distutils.core import setup, Extension
 
 import numpy
@@ -13,14 +14,24 @@ try:
 except AttributeError:
     numpy_include = numpy.get_numpy_include()
 
-include_dirs = [numpy_include, '../Source']
+boxlib_home = os.environ.get('BOXLIB_HOME', '../../BoxLib')
+boxlib_includes = ['Src/C_BaseLib', 
+                   'Src/C_ParticleLib',
+                   'Src/C_BoundaryLib',
+                   'Src/C_AmrCoreLib',
+                   'Tools/C_scripts']
+boxlib_includes = [os.path.join(boxlib_home, ii) for ii in boxlib_includes]
+
+include_dirs = [numpy_include, '../Source'] + boxlib_includes
 
 example_module = Extension('pywarpx._warpxC',
-                           swig_opts=['-c++', '-outdir','pywarpx'],
+                           swig_opts=['-c++', '-outdir', 'pywarpx'],
                            sources=['warpxC.i'],
                            library_dirs=['.'],
                            libraries=['warpx'],
                            include_dirs = include_dirs,
+                           define_macros = [('BL_USE_MPI','1'), ('BL_SPACEDIM','3'), ('BL_FORT_USE_UNDERSCORE','1'), ('USE_PARTICLES', None)],
+                           extra_compile_args = ['-std=c++11'],
                            )
 
 setup (name = 'pywarpx',
diff --git a/Python/warpxC.i b/Python/warpxC.i
index 49a85ce51..0c94829cf 100644
--- a/Python/warpxC.i
+++ b/Python/warpxC.i
@@ -4,6 +4,7 @@
 #include <WarpXWrappers.h>
 
 #define SWIG_FILE_WITH_INIT
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
 %}
 %include "numpy.i"
 %init %{
@@ -46,3 +47,4 @@ void wrapped_addNParticles(int speciesnumber, int lenx, double* x, int leny, dou
 }
 %}
 
+%include classwrapper.i