Add Fly Stem Cells and accompanying proliferation module

src/arcade/core/util/Vector.java

@@ -33,7 +33,7 @@ public Vector(Double3D vector) {
      * @return the x component
      */
     public double getX() {
-        return vector.x;
+        return vector.getX();
     }
 
     /**
@@ -42,7 +42,7 @@ public double getX() {
      * @return the y component
      */
     public double getY() {
-        return vector.y;
+        return vector.getY();
     }
 
     /**
@@ -51,7 +51,7 @@ public double getY() {
      * @return the z component
      */
     public double getZ() {
-        return vector.z;
+        return vector.getZ();
     }
 
     /**

src/arcade/potts/agent/cell/PottsCell.java

@@ -79,7 +79,7 @@
     private final EnumMap<Region, Double> targetRegionSurfaces;
 
     /** Critical volume for cell [voxels]. */
-    final double criticalVolume;
+    double criticalVolume;
 
     /** Critical volumes for cell by region [voxels]. */
     final EnumMap<Region, Double> criticalRegionVolumes;
@@ -295,6 +295,10 @@
         return criticalVolume;
     }
 
+    public void setCriticalVolume(double newCriticaVolume) {
+        criticalVolume = newCriticaVolume;
+    }
+
     /**
      * Gets the critical volume for a region.
      *

src/arcade/potts/agent/cell/PottsCellContainer.java

@@ -176,6 +176,10 @@ public Cell convert(
                 return new PottsCellFlyNeuron(this, location, parameters, links);
             case "fly-gmc":
                 return new PottsCellFlyGMC(this, location, parameters, links);
+            case "fly-stem-wt":
+                return new PottsCellFlyStem(this, location, parameters, links);
+            case "fly-stem-mudmut":
+                return new PottsCellFlyStem(this, location, parameters, links);
             default:
             case "stem":
                 return new PottsCellStem(this, location, parameters, links);

src/arcade/potts/agent/cell/PottsCellFlyStem.java

@@ -0,0 +1,165 @@
+package arcade.potts.agent.cell;
+
+import ec.util.MersenneTwisterFast;
+import arcade.core.agent.cell.CellState;
+import arcade.core.env.location.Location;
+import arcade.core.util.GrabBag;
+import arcade.core.util.Parameters;
+import arcade.core.util.Vector;
+import arcade.potts.agent.module.PottsModule;
+import arcade.potts.agent.module.PottsModuleProliferationFlyStem;
+import arcade.potts.util.PottsEnums.Phase;
+import arcade.potts.util.PottsEnums.State;
+
+/** Extension of {@link PottsCell} for fly stem cells. */
+public class PottsCellFlyStem extends PottsCell {
+
+    /** Enum outlining parameters for each cell type. */
+    public enum StemType {
+        /** Wild type stem cell. */
+        WT(50, 75, 0, 0.25),
+
+        /** mud Mutant stem cell. */
+        MUDMUT(50, 50, -90, 0.5);
+
+        /** Percentage x offset from cell edge where division will occur. */
+        public final int splitOffsetPercentX;
+
+        /** Percentage y offset from cell edge where division will occur. */
+        public final int splitOffsetPercentY;
+
+        /** Default direction of division is rotated this much off the apical vector. */
+        public final double splitDirectionRotation;
+
+        /**
+         * The proportion of the stem cell's critical volume that will be the daughter cell's
+         * critical volume.
+         */
+        public final double daughterCellCriticalVolumeProportion;
+
+        /**
+         * Constructor for StemType.
+         *
+         * @param splitOffsetPercentX percentage x offset from cell edge where division will occur
+         * @param splitOffsetPercentY percentage y offset from cell edge where division will occur
+         * @param splitDirectionRotation the plane of division's rotation off the apical vector
+         * @param daughterCellCriticalVolumeProportion proportion of the stem cell's critical volume
+         *     that will be the daughter cell's critical volume
+         */
+        StemType(
+                int splitOffsetPercentX,
+                int splitOffsetPercentY,
+                double splitDirectionRotation,
+                double daughterCellCriticalVolumeProportion) {
+            this.splitOffsetPercentX = splitOffsetPercentX;
+            this.splitOffsetPercentY = splitOffsetPercentY;
+            this.splitDirectionRotation = splitDirectionRotation;
+            this.daughterCellCriticalVolumeProportion = daughterCellCriticalVolumeProportion;
+        }
+    }
+
+    /** The type of stem cell. */
+    public final StemType stemType;
+
+    private Vector apicalAxis;
+
+    /**
+     * Constructor for PottsCellFlyStem.
+     *
+     * @param container the container for the cell
+     * @param location the location of the cell
+     * @param parameters the parameters for the cell
+     * @param links the links for the cell
+     * @throws IllegalArgumentException if the stem type is not recognized
+     */
+    public PottsCellFlyStem(
+            PottsCellContainer container, Location location, Parameters parameters, GrabBag links) {
+        super(container, location, parameters, links);
+
+        if (module != null) {
+            ((PottsModule) module).setPhase(Phase.UNDEFINED);
+        }
+
+        String stemTypeString = parameters.getString("CLASS");
+        switch (stemTypeString) {
+            case "fly-stem-wt":
+                stemType = StemType.WT;
+                break;
+            case "fly-stem-mudmut":
+                stemType = StemType.MUDMUT;
+                break;
+            default:
+                throw new IllegalArgumentException("Unknown StemType: " + stemTypeString);
+        }
+    }
+
+    public void setApicalAxis(Vector apicalAxis) {
+        this.apicalAxis = apicalAxis;
+    }
+
+    /**
+     * Gets the apical axis of the cell. If no apical axis is set, it returns a vector along the y
+     * axis as a default vector
+     *
+     * @return the apical axis of the cell
+     */
+    public Vector getApicalAxis() {
+        if (apicalAxis != null) {
+            return apicalAxis;
+        } else {
+            return new Vector(0, 1, 0);
+        }
+    }
+
+    @Override
+    public PottsCellContainer make(int newID, CellState newState, MersenneTwisterFast random) {
+        throw new UnsupportedOperationException(
+                "make(int, CellState, MersenneTwisterFast) not supported. Please use make(int, CellState, MersenneTwisterFast, int, double) instead.");
+    }
+
+    public PottsCellContainer make(
+            int newID,
+            CellState newState,
+            MersenneTwisterFast random,
+            int newPop,
+            double daughterCellCriticalVolume) {
+
+        divisions++;
+
+        return new PottsCellContainer(
+                newID,
+                id,
+                newPop,
+                age,
+                divisions,
+                newState,
+                Phase.UNDEFINED,
+                0,
+                null,
+                daughterCellCriticalVolume,
+                criticalHeight,
+                criticalRegionVolumes,
+                criticalRegionHeights);
+    }
+
+    @Override
+    void setStateModule(CellState newState) {
+        switch ((State) newState) {
+            case PROLIFERATIVE:
+                module = new PottsModuleProliferationFlyStem(this);
+                break;
+            default:
+                module = null;
+                break;
+        }
+    }
+
+    /**
+     * Gets the stem type of the cell.
+     *
+     * @return the stem type of the cell
+     */
+    public final StemType getStemType() {
+        return stemType;
+    }
+}

src/arcade/potts/agent/module/PottsModuleFlyGMCDifferentiation.java

@@ -11,6 +11,7 @@
 import arcade.potts.env.location.PottsLocation2D;
 import arcade.potts.sim.Potts;
 import arcade.potts.sim.PottsSimulation;
+import arcade.potts.util.PottsEnums.Phase;
 import arcade.potts.util.PottsEnums.State;
 
 /**
@@ -20,6 +21,27 @@
  */
 public class PottsModuleFlyGMCDifferentiation extends PottsModuleProliferationSimple {
 
+    void stepVolOnly(MersenneTwisterFast random, Simulation sim) {
+        // Increase size of cell.
+        cell.updateTarget(cellGrowthRate, sizeTarget);
+        boolean sizeCheck = cell.getVolume() >= sizeTarget * cell.getCriticalVolume();
+        if (sizeCheck) {
+            addCell(random, sim);
+            setPhase(Phase.UNDEFINED);
+        }
+    }
+
+    @Override
+    public void step(MersenneTwisterFast random, Simulation sim) {
+        switch (phase) {
+            case UNDEFINED:
+                stepVolOnly(random, sim);
+                break;
+            default:
+                break;
+        }
+    }
+
     /**
      * Creates a fly GMC proliferation module.
      *
@@ -65,7 +87,7 @@
                         newPop,
                         oldCell.getAge(),
                         oldCell.getDivisions(),
-                        State.QUIESCENT,
+                        State.UNDEFINED,
                         null,
                         0,
                         null,