Пример #1
0
  /**
   * \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();
  }
Пример #2
0
  /**
   * \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()");
    }
  }
Пример #3
0
  /**
   * \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);
  }
Пример #4
0
  /**
   * \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;
    }
  }
Пример #5
0
  /**
   * \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);
    }
  }
Пример #6
0
  /**
   * \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;
  }
Пример #7
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();
  }
Пример #8
0
  @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;
  }
Пример #9
0
 /**
  * \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;
 }