/**
* \brief On agent division, divides the mass between the old and new agent, at a specified
* fraction
*
* <p>On agent division, divides the mass between the old and new agent, at a specified fraction
*
* @param baby The new agent, which is inheriting mass
* @param babyMassFrac The fraction of this agents mass that should be transferred to the new
* agent
*/
public void divideCompounds(LocatedAgent baby, double babyMassFrac) {
// Choose the division plan and apply position modifications
for (int i = 0; i < particleMass.length; i++) {
baby.particleMass[i] *= babyMassFrac;
this.particleMass[i] *= 1 - babyMassFrac;
}
// Update radius, mass, volumes and growth rates
updateSize();
baby.updateSize();
updateGrowthRates();
baby.updateGrowthRates();
}
/**
* \brief Create a new agent in a specified position
*
* <p>Create a new agent in a specified position
*
* @param position Vector stating where this agent should be located
*/
public void createNewAgent(ContinuousVector position) {
try {
// Get a clone of the progenitor
LocatedAgent baby = (LocatedAgent) sendNewAgent();
baby.giveName();
// randomize its mass
baby.mutatePop();
baby.updateSize();
this._myDivRadius = getDivRadius();
baby._myDivRadius = getDivRadius();
baby._myDeathRadius = getDeathRadius();
// Just to avoid to be in the carrier
position.x += this._totalRadius;
baby.setLocation(position);
baby.registerBirth();
} catch (CloneNotSupportedException e) {
utils.LogFile.writeLog("Error met in LocAgent:createNewAgent()");
}
}
/**
* \brief Pulling : The movement of agents by a shrinking biofilm. Move calculated and added to
* the agents movement vector.
*
* <p>The movement of agents by a shrinking biofilm. Move calculated and added to the agents
* movement vector.
*
* @param aNeighbor Reference to the potentially shoving neighbour
* @param isMutual Whether movement is shared between two agents or applied only to this one
* @param gain Double noting change in position
* @return Boolean stating whether pulling is detected (true) or not (false)
*/
public boolean addSpringMovement(LocatedAgent aNeighbor, boolean isMutual, double gain) {
double d, distance, delta;
if (aNeighbor == this) return false;
// Build the escape vector and find the distance between you and your
// neighbourhood
d = computeDifferenceVector(_location, aNeighbor._location);
_diff.normalizeVector();
distance = getShoveRadius() + aNeighbor.getShoveRadius();
distance += getSpeciesParam().shoveLimit;
delta = d - distance;
double lMax = _totalRadius;
if (delta > 0) gain *= Math.exp(-delta * 5 / (lMax));
if (delta > lMax) gain = 0;
/* Apply shoving _________________________________________________ */
if (isMutual) {
_diff.times(-0.5 * delta * gain);
this._movement.add(_diff);
aNeighbor._movement.subtract(_diff);
} else {
_diff.times(-delta * gain);
this._movement.add(_diff);
}
return (_movement.norm() > _radius * gain);
}
/**
* \brief Mutual shoving : The movement by shoving of an agent is calculated based on the cell
* overlap and added to the agents movement vector.
*
* <p>Mutual shoving : The movement by shoving of an agent is calculated based on the cell overlap
* and added to the agents movement vector. Both agents are moved of half the overlapping distance
* in opposite directions.
*
* @param aNeighbour Reference to the potentially shoving neighbour
* @param isMutual Whether movement is shared between two agents or applied only to this one
* @param gain Double noting change in position
* @return Boolean stating whether shoving is detected (true) or not (false)
*/
public boolean addPushMovement(LocatedAgent aNeighbour, boolean isMutual, double gain) {
double d, distance;
if (aNeighbour == this) return false;
// Build the escape vector and find the distance between you and your
// neighbourhood
d = computeDifferenceVector(_location, aNeighbour._location);
_diff.normalizeVector();
// Compute effective cell-cell distance
distance = getShoveRadius() + aNeighbour.getShoveRadius();
distance += getSpeciesParam().shoveLimit;
distance = d - distance;
/* Apply shoving _________________________________________________ */
// Compute shoving distance for the current agent
if (distance <= 0) {
if (isMutual) {
_diff.times(gain * 0.5 * Math.abs(distance));
this._movement.add(_diff);
aNeighbour._movement.subtract(_diff);
} else {
_diff.times(Math.abs(gain * distance));
this._movement.add(_diff);
}
return true;
} else {
return false;
}
}
/**
* \brief Find a sibling of this agent
*
* <p>Find a sibling of this agent
*
* @param indexSpecies The index used to reference this species in the simulation dictionary
*/
public void findCloseSiblings(int indexSpecies) {
int nNb;
boolean test;
double shoveDist;
LocatedAgent aNb;
getPotentialShovers(getInteractDistance());
nNb = _myNeighbors.size();
for (int iNb = 0; iNb < nNb; iNb++) {
aNb = _myNeighbors.removeFirst();
// test EPS-species
test = (indexSpecies == aNb.speciesIndex);
// Test distance
shoveDist = 2 * (getShoveRadius() + aNb.getShoveRadius());
test = test && computeDifferenceVector(_location, aNb.getLocation()) <= shoveDist;
if (test & aNb != this) _myNeighbors.addLast(aNb);
}
}
/**
* \brief With it determined that cell division will occur, create a new agent from the existing
* one
*
* <p>With it determined that cell division will occur, create a new agent from the existing one
*
* @throws CloneNotSupportedException Thrown if the agent cannot be cloned
*/
public void makeKid() throws CloneNotSupportedException {
// Create the new instance
LocatedAgent baby = (LocatedAgent) sendNewAgent();
// Note that mutateAgent() does nothing yet
baby.mutateAgent();
this._myDivRadius = getDivRadius();
baby._myDivRadius = getDivRadius();
baby._myDeathRadius = getDeathRadius();
// Update the lineage
recordGenealogy(baby);
// Share mass of all compounds between two daughter cells and compute
// new size
divideCompounds(baby, getBabyMassFrac());
// sonia:chemostat
if (Simulator.isChemostat) {
// upon division the daughter cells remain with the coordinates of their progenitor
} else {
// Compute movement to apply to both cells
setDivisionDirection(getInteractDistance(baby) / 2);
// move both daughter cells
baby._movement.subtract(_divisionDirection);
_movement.add(_divisionDirection);
}
// Now register the agent inside the guilds and the agent grid
baby.registerBirth();
baby._netVolumeRate = 0;
}
/**
* \brief On agent division, transfers EPS between the old and new agent, at a specified ratio
*
* <p>On agent division, transfers EPS between the old and new agent, at a specified ratio
*
* @param baby The new agent, which is inheriting mass
* @param splitRatio The ratio of the EPS that should be transferred to the new agent
*/
public void transferCompounds(LocatedAgent baby, double splitRatio) {
// Choose the division plan and apply position modifications
double m;
for (int i = 0; i < particleMass.length; i++) {
m = this.particleMass[i] * splitRatio;
baby.particleMass[i] += m;
this.particleMass[i] = this.particleMass[i] - m;
}
// Update radius, mass and volumes
updateSize();
baby.updateSize();
}
@SuppressWarnings("unchecked")
/**
* \brief Creates a daughter Located Agent by cloning this agent and parameter objects
*
* <p>Creates a daughter Located Agent by cloning this agent and parameter objects
*
* @throws CloneNotSupportedException Thrown if the agent cannot be cloned
*/
public Object clone() throws CloneNotSupportedException {
LocatedAgent o = (LocatedAgent) super.clone();
o._location = (ContinuousVector) this._location.clone();
o._movement = (ContinuousVector) this._movement.clone();
o._divisionDirection = (ContinuousVector) this._divisionDirection.clone();
o._myNeighbors = (LinkedList<LocatedAgent>) this._myNeighbors.clone();
o._agentGridIndex = this._agentGridIndex;
return (Object) o;
}
/**
* \brief Return the shoving interaction distance to be used in shoving against a specified agent
*
* <p>Return the shoving interaction distance to be used in shoving against a specified agent
*
* @return Double specifying the shoving interaction distance that will be applied
*/
public double getInteractDistance(LocatedAgent baby) {
return getShoveRadius() + baby.getShoveRadius() + ((LocatedParam) _speciesParam).shoveLimit;
}