OffLattice support

.circleci/config.yml

@@ -18,7 +18,7 @@ jobs:
     parameters:
       pyver:
         type: enum
-        enum: ["cp35-cp35m", "cp36-cp36m", "cp37-cp37m"]
+        enum: ["cp35-cp35m", "cp36-cp36m", "cp37-cp37m", "cp38-cp38"]
     steps:
       - setup_remote_docker
       - checkout
@@ -42,8 +42,7 @@ jobs:
           name: Install auditwheel from source
           command: |
             git clone https://github.com/pypa/auditwheel.git
-            cd auditwheel && /opt/python/<< parameters.pyver >>/bin/python setup.py install
-            /opt/python/<< parameters.pyver >>/bin/pip install pyelftools
+            /opt/python/<< parameters.pyver >>/bin/python -m pip install ./auditwheel
       - run:
           name: Build E-Cell4
           command: |
@@ -66,3 +65,6 @@ workflows:
       - build:
           name: build_py37
           pyver: cp37-cp37m
+      - build:
+          name: build_py38
+          pyver: cp38-cp38

ecell4/core/HCPLatticeSpace.cpp

@@ -6,51 +6,49 @@
 #include <boost/numeric/interval/detail/msvc_rounding_control.hpp>
 #endif
 
-namespace ecell4 {
+namespace ecell4
+{
 
 #ifdef WIN32_MSC
 double rint(const double x)
 {
     return boost::numeric::interval_lib::detail::rint(x);
 }
 
-double round(const double x)
-{
-    return floor(x + 0.5);
-}
+double round(const double x) { return floor(x + 0.5); }
 #endif
 
-void HCPLatticeSpace::set_lattice_properties(const Real3& edge_lengths, const bool is_periodic)
+void HCPLatticeSpace::set_lattice_properties(const Real3 &edge_lengths,
+                                             const bool is_periodic)
 {
-    //XXX: derived from SpatiocyteStepper::setLatticeProperties()
+    // XXX: derived from SpatiocyteStepper::setLatticeProperties()
     HCP_L = voxel_radius_ / sqrt(3.0);
     HCP_X = voxel_radius_ * sqrt(8.0 / 3.0); // Lx
-    HCP_Y = voxel_radius_ * sqrt(3.0); // Ly
+    HCP_Y = voxel_radius_ * sqrt(3.0);       // Ly
 
-    const Real& lengthX = edge_lengths[0];
-    const Real& lengthY = edge_lengths[1];
-    const Real& lengthZ = edge_lengths[2];
+    const Real &lengthX = edge_lengths[0];
+    const Real &lengthY = edge_lengths[1];
+    const Real &lengthZ = edge_lengths[2];
 
     col_size_ = (Integer)rint(lengthX / HCP_X);
     layer_size_ = (Integer)rint(lengthY / HCP_Y);
     row_size_ = (Integer)rint((lengthZ / 2) / voxel_radius_);
 
     if (is_periodic)
     {
-        // The number of voxels in each axis must be even for a periodic boundary.
+        // The number of voxels in each axis must be even for a periodic
+        // boundary.
         col_size_ = (col_size_ % 2 == 0 ? col_size_ : col_size_ + 1);
         layer_size_ = (layer_size_ % 2 == 0 ? layer_size_ : layer_size_ + 1);
         row_size_ = (row_size_ % 2 == 0 ? row_size_ : row_size_ + 1);
     }
 
-    edge_lengths_ = Real3(
-        col_size_ * HCP_X,
-        layer_size_ * HCP_Y,
-        row_size_ * voxel_radius_ * 2);
+    edge_lengths_ = Real3(col_size_ * HCP_X, layer_size_ * HCP_Y,
+                          row_size_ * voxel_radius_ * 2);
 
     row_size_ += 2;
     layer_size_ += 2;
     col_size_ += 2;
 }
 
-} // ecell4
+} // namespace ecell4

ecell4/core/HCPLatticeSpace.hpp

@@ -6,16 +6,14 @@
 namespace ecell4
 {
 
-class HCPLatticeSpace
-    : public VoxelSpaceBase
+class HCPLatticeSpace : public VoxelSpaceBase
 {
 public:
-
     typedef VoxelSpaceBase base_type;
 
 public:
-
-    HCPLatticeSpace(const Real3& edge_lengths, const Real& voxel_radius, const bool is_periodic)
+    HCPLatticeSpace(const Real3 &edge_lengths, const Real &voxel_radius,
+                    const bool is_periodic)
         : base_type(voxel_radius)
     {
         set_lattice_properties(edge_lengths, is_periodic);
@@ -26,99 +24,86 @@ class HCPLatticeSpace
         ; // do nothing
     }
 
-    virtual void reset(const Real3& edge_lengths, const Real& voxel_radius, const bool is_periodic)
+    virtual void reset(const Real3 &edge_lengths, const Real &voxel_radius,
+                       const bool is_periodic)
     {
         voxel_radius_ = voxel_radius;
 
         set_lattice_properties(edge_lengths, is_periodic);
     }
 
-    void set_lattice_properties(const Real3& edge_lengths, const bool is_periodic);
+    void set_lattice_properties(const Real3 &edge_lengths,
+                                const bool is_periodic);
 
     /**
      * Primitives
      */
 
-    const Real3& edge_lengths() const
-    {
-        return edge_lengths_;
-    }
+    const Real3 &edge_lengths() const { return edge_lengths_; }
 
-    virtual const Integer col_size() const
-    {
-        return col_size_ - 2;
-    }
+    virtual const Integer col_size() const { return col_size_ - 2; }
 
-    virtual const Integer row_size() const
-    {
-        return row_size_ - 2;
-    }
+    virtual const Integer row_size() const { return row_size_ - 2; }
 
-    virtual const Integer layer_size() const
-    {
-        return layer_size_ - 2;
-    }
+    virtual const Integer layer_size() const { return layer_size_ - 2; }
 
     /**
      Coordinate transformations
      */
-    coordinate_type global2coordinate(const Integer3& global) const
+    coordinate_type global2coordinate(const Integer3 &global) const
     {
         const Integer3 g(global.col + 1, global.row + 1, global.layer + 1);
         return g.row + row_size_ * (g.col + col_size_ * g.layer);
     }
 
-    Integer3 coordinate2global(const coordinate_type& coord) const
+    Integer3 coordinate2global(const coordinate_type &coord) const
     {
         const Integer NUM_COLROW(row_size_ * col_size_);
         const Integer LAYER(coord / NUM_COLROW);
         const Integer SURPLUS(coord - LAYER * NUM_COLROW);
         const Integer COL(SURPLUS / row_size_);
         const Integer3 global(COL, SURPLUS - COL * row_size_, LAYER);
-        const Integer3 retval(
-            global.col - 1, global.row - 1, global.layer - 1);
+        const Integer3 retval(global.col - 1, global.row - 1, global.layer - 1);
         return retval;
     }
 
-    Real3 coordinate2position(const coordinate_type& coord) const
+    Real3 coordinate2position(const coordinate_type &coord) const
     {
         return global2position(coordinate2global(coord));
     }
 
-    coordinate_type position2coordinate(const Real3& pos) const
+    coordinate_type position2coordinate(const Real3 &pos) const
     {
         return global2coordinate(position2global(pos));
     }
 
-    Real3 global2position(const Integer3& global) const
+    Real3 global2position(const Integer3 &global) const
     {
         // the center point of a voxel
         const Real3 pos(
-            global.col * HCP_X,
-            (global.col % 2) * HCP_L + HCP_Y * global.layer,
-            (global.row * 2 + (global.layer + global.col) % 2)
-                * voxel_radius_);
+            global.col * HCP_X, (global.col % 2) * HCP_L + HCP_Y * global.layer,
+            (global.row * 2 + (global.layer + global.col) % 2) * voxel_radius_);
         return pos;
     }
 
-    Integer3 position2global(const Real3& pos) const
+    Integer3 position2global(const Real3 &pos) const
     {
         const Integer col(round(pos[0] / HCP_X));
         const Integer layer(round((pos[1] - (col % 2) * HCP_L) / HCP_Y));
-        const Integer row(round(
-            (pos[2] / voxel_radius_ - ((layer + col) % 2)) / 2));
+        const Integer row(
+            round((pos[2] / voxel_radius_ - ((layer + col) % 2)) / 2));
         const Integer3 global(col, row, layer);
         return global;
     }
 
-    Integer num_neighbors(const coordinate_type& coord) const
+    Integer num_neighbors(const coordinate_type &coord) const
     {
-        if (!is_inside(coord)) return 0;
+        if (!is_inside(coord))
+            return 0;
         return 12;
     }
 
-    coordinate_type periodic_transpose(
-        const coordinate_type& coord) const
+    coordinate_type periodic_transpose(const coordinate_type &coord) const
     {
         Integer3 global(coordinate2global(coord));
 
@@ -128,15 +113,15 @@ class HCPLatticeSpace
 
         global.col = global.col < 0 ? global.col + col_size() : global.col;
         global.row = global.row < 0 ? global.row + row_size() : global.row;
-        global.layer = global.layer < 0 ? global.layer + layer_size() : global.layer;
+        global.layer =
+            global.layer < 0 ? global.layer + layer_size() : global.layer;
 
         return global2coordinate(global);
     }
 
 protected:
-
-    coordinate_type get_neighbor_(
-        const coordinate_type& coord, const Integer& nrand) const
+    coordinate_type get_neighbor_(const coordinate_type &coord,
+                                  const Integer &nrand) const
     {
         const Integer NUM_COLROW(col_size_ * row_size_);
         const Integer NUM_ROW(row_size_);
@@ -177,24 +162,20 @@ class HCPLatticeSpace
     }
 
 public:
-
-    bool is_in_range(const coordinate_type& coord) const
+    bool is_in_range(const coordinate_type &coord) const
     {
         return coord >= 0 && coord < row_size_ * col_size_ * layer_size_;
     }
 
-    virtual bool is_inside(const coordinate_type& coord) const
+    virtual bool is_inside(const coordinate_type &coord) const
     {
         const Integer3 global(coordinate2global(coord));
-        return global.col >= 0 && global.col < col_size()
-            && global.row >= 0 && global.row < row_size()
-            && global.layer >= 0 && global.layer < layer_size();
+        return global.col >= 0 && global.col < col_size() && global.row >= 0 &&
+               global.row < row_size() && global.layer >= 0 &&
+               global.layer < layer_size();
     }
 
-    virtual Integer size() const
-    {
-        return row_size_ * col_size_ * layer_size_;
-    }
+    virtual Integer size() const { return row_size_ * col_size_ * layer_size_; }
 
     virtual Integer3 shape() const
     {
@@ -207,12 +188,11 @@ class HCPLatticeSpace
     }
 
 protected:
-
     Real3 edge_lengths_;
     Real HCP_L, HCP_X, HCP_Y;
     Integer row_size_, layer_size_, col_size_;
 };
 
-} // ecell4
+} // namespace ecell4
 
 #endif /* ECELL4_LATTICE_SPACE_BASE_HPP */