Add fly cells and accompanying proliferation module

.github/config/checks.xml

@@ -33,11 +33,13 @@
         <property name="id" value="LineLength"/>
         <property name="fileExtensions" value="java" />
         <property name="max" value="100"/>
+        <property name="severity" value="warning"/>
     </module>
     <module name="LineLength">
         <property name="id" value="LineLengthTest"/>
         <property name="fileExtensions" value=".java" />
         <property name="max" value="120"/>
+        <property name="severity" value="error"/>
     </module>
 
     <!-- Checks for whitespace -->

.github/workflows/lint.yml

@@ -15,12 +15,12 @@ jobs:
         fetch-depth: 0
 
     - name: Lint code base
-      uses: dbelyaev/action-checkstyle@v0.9.5
+      uses: dbelyaev/action-checkstyle@v3.0.0
       with:
         github_token: ${{ secrets.GITHUB_TOKEN }}
         reporter: github-check
         checkstyle_config: .github/config/checks.xml
-        fail_on_error: true
+        fail_level: error
 
   update-lint-badges:
     if: ${{ always() && github.ref == 'refs/heads/main' }}

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 @@ public abstract class PottsCell implements Cell {
     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,15 @@ public double getCriticalVolume() {
         return criticalVolume;
     }
 
+    /**
+     * Sets the critical volume of the cell.
+     *
+     * @param newCriticalVolume the new critical volume
+     */
+    public void setCriticalVolume(double newCriticalVolume) {
+        criticalVolume = newCriticalVolume;
+    }
+
     /**
      * 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/PottsCellFactory.java

@@ -1,5 +1,6 @@
 package arcade.potts.agent.cell;
 
+import java.security.InvalidParameterException;
 import java.util.ArrayList;
 import java.util.EnumMap;
 import java.util.HashMap;
@@ -213,8 +214,13 @@
             if (linkKeys.size() > 0) {
                 links = new GrabBag();
                 for (String linkKey : linkKeys) {
-                    int popLink = series.populations.get(linkKey).getInt("CODE");
-                    links.add(popLink, linksBox.getDouble(linkKey));
+                    try {
+                        int popLink = series.populations.get(linkKey).getInt("CODE");
+                        links.add(popLink, linksBox.getDouble(linkKey));
+                    } catch (Exception e) {
+                        throw new InvalidParameterException(
+                                "A population link is set that references a population that does not exist.");
+                    }
                 }
             }
 

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

@@ -13,8 +13,8 @@
  * Implementation of {@link PottsCell} for fly GMC agents. These cells divide into two {@link
  * PottsCellFlyNeuron} cells. The links must be set in the setup file so that 100% of the daughter
  * cells are Neurons. The differentiation of the parent cell is handled by the {@link
- * PottsModuleFlyGMCDifferentiation} module. The basal apoptosis rate of this cell should be set to
- * 0 in the setup file.
+ * PottsModuleProliferationVolumeBasedDivision} module. The basal apoptosis rate of this cell should
+ * be set to 0 in the setup file.
  */
 public class PottsCellFlyGMC extends PottsCell {
 

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

@@ -0,0 +1,163 @@
+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.PottsModuleFlyStemProliferation;
+import arcade.potts.util.PottsEnums.Phase;
+import static arcade.potts.util.PottsEnums.State;
+
+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 PottsModuleFlyStemProliferation(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/cell/PottsCellStem.java

@@ -9,7 +9,7 @@
 import arcade.potts.agent.module.PottsModuleApoptosisSimple;
 import arcade.potts.agent.module.PottsModuleAutosis;
 import arcade.potts.agent.module.PottsModuleNecrosis;
-import arcade.potts.agent.module.PottsModuleProliferationSimple;
+import arcade.potts.agent.module.PottsModuleProliferationWithCellCycleCheckSimple;
 import arcade.potts.agent.module.PottsModuleQuiescence;
 import static arcade.potts.util.PottsEnums.Region;
 import static arcade.potts.util.PottsEnums.State;
@@ -73,7 +73,7 @@ void setStateModule(CellState newState) {
                 module = new PottsModuleQuiescence(this);
                 break;
             case PROLIFERATIVE:
-                module = new PottsModuleProliferationSimple(this);
+                module = new PottsModuleProliferationWithCellCycleCheckSimple(this);
                 break;
             case APOPTOTIC:
                 module = new PottsModuleApoptosisSimple(this);

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

@@ -14,11 +14,13 @@
 import arcade.potts.util.PottsEnums.State;
 
 /**
- * Implementation of {@link PottsModuleProliferationSimple} for fly GMC agents. These cells divide
- * into two {@link PottsCellFlyNeuron} cells. The links must be set in the setup file so that 100%
- * of the daughter cells are Neurons.
+ * Implementation of {@link PottsModuleProliferationVolumeBasedDivision} for fly GMC agents. These
+ * cells divide into two {@link PottsCellFlyNeuron} cells. The links must be set in the setup file
+ * so that 100% of the daughter cells are Neurons.
  */
-public class PottsModuleFlyGMCDifferentiation extends PottsModuleProliferationSimple {
+public class PottsModuleFlyGMCDifferentiation extends PottsModuleProliferationVolumeBasedDivision {
+
+    Boolean pdeLike;
 
     /**
      * Creates a fly GMC proliferation module.
@@ -27,8 +29,18 @@
      */
     public PottsModuleFlyGMCDifferentiation(PottsCellFlyGMC cell) {
         super(cell);
+        pdeLike = (cell.getParameters().getInt("proliferation/PDELIKE") != 0);
     }
 
+    /**
+     * Adds a cell to the simulation.
+     *
+     * <p>The cell location is split. The new neuron cell is created, initialized, and added to the
+     * schedule. This cell's location is also assigned to a new Neuron cell.
+     *
+     * @param random the random number generator
+     * @param sim the simulation instance
+     */
     @Override
     void addCell(MersenneTwisterFast random, Simulation sim) {
         Potts potts = ((PottsSimulation) sim).getPotts();
@@ -82,4 +94,42 @@
         differentiatedGMC.reset(potts.ids, potts.regions);
         differentiatedGMC.schedule(sim.getSchedule());
     }
+
+    public void updateGrowthRate(Simulation sim) {
+        if (!dynamicGrowthRateVolume) {
+            cellGrowthRate = cellGrowthRateBase;
+        } else {
+            if (!pdeLike) {
+                updateCellVolumeBasedGrowthRate(
+                        cell.getLocation().getVolume(), cell.getCriticalVolume());
+            } else {
+                // PDE-like: use population-wide averages for GMCs (same pop as this cell)
+                sim.util.Bag objs = sim.getGrid().getAllObjects();
+
+                double volSum = 0.0;
+                double critSum = 0.0;
+                int count = 0;
+
+                for (int i = 0; i < objs.numObjs; i++) {
+                    Object o = objs.objs[i];
+                    if (!(o instanceof arcade.potts.agent.cell.PottsCell)) continue;
+
+                    arcade.potts.agent.cell.PottsCell c = (arcade.potts.agent.cell.PottsCell) o;
+                    if (c.getPop() != cell.getPop()) continue; // keep to same population
+
+                    if (o instanceof arcade.potts.agent.cell.PottsCellFlyGMC) {
+                        arcade.potts.agent.cell.PottsCellFlyGMC gmc =
+                                (arcade.potts.agent.cell.PottsCellFlyGMC) o;
+                        volSum += gmc.getLocation().getVolume();
+                        critSum += gmc.getCriticalVolume();
+                        count++;
+                    }
+                }
+                double avgVolume = volSum / count;
+                double avgCritVol = critSum / count;
+                updateCellVolumeBasedGrowthRate(avgVolume, avgCritVol);
+                System.out.println("GMC " + cell.getID() + "growth rate = " + cellGrowthRate);
+            }
+        }
+    }
 }