Ejemplo n.º 1
0
  /**
   * \brief With the agent move calculated, apply this movement, taking care to respect boundary
   * conditions
   *
   * <p>With the agent move calculated, apply this movement, taking care to respect boundary
   * conditions
   */
  public double move() {
    if (!_movement.isValid()) {
      LogFile.writeLog("Incorrect movement coordinates");
      _movement.reset();
    }

    if (!_agentGrid.is3D && _movement.z != 0) {
      _movement.z = 0;
      _movement.reset();
      LogFile.writeLog("Try to move in z direction !");
    }

    // No movement planned, finish here
    if (_movement.isZero()) return 0;

    // Test the boundaries
    checkBoundaries();

    // Now apply the movement
    _location.set(_newLoc);
    _agentGrid.registerMove(this);

    double delta = _movement.norm();
    _movement.reset();

    return delta / _totalRadius;
  }
Ejemplo n.º 2
0
  /**
   * \brief Update the radius of the agent from the current mass (and then the volume) of the agent
   * (EPS included)
   *
   * <p>Update the radius of the agent from the current mass (and then the volume) of the agent (EPS
   * included)
   */
  public void updateSize() {
    // Update the totalMass field (sum of the particles masses)
    updateMass();

    if (_totalMass < 0)
      LogFile.writeLog("Warning: negative mass on agent " + _family + ", " + _genealogy);

    // Sum of (particles masses / particles density)
    updateVolume();

    // Compute radius according to the volume
    updateRadius();

    // sonia:chemostat
    if (Simulator.isChemostat) {
      // don't do the update of attachment/detachment

    } else {

      // Check if by chance the agent is close enough to a support to be
      // attached

      updateAttachment();
    }
  }
Ejemplo n.º 3
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()");
    }
  }
Ejemplo n.º 4
0
  /**
   * \brief Used in 'one-time' attachment scenarios, where clones of the progenitor are created in
   * the birth area of the substratum.
   *
   * @param spRoot The XML mark-up group for a particular species being created.
   */
  public void createPop(XMLParser spRoot) {
    int howMany = spRoot.getAttributeInt("number");
    if (howMany <= 0) return;

    // Define the birth area - this is taken from the coordinates tags in the protocol file
    // (Nov13) OR if an initial area is not declared, this is the whole Y and Z of the domain with a
    // height of 1.
    ContinuousVector[] _initArea = defineSquareArea(spRoot);
    // Create all the required agents
    ContinuousVector cc = new ContinuousVector();

    for (int i = 0; i < howMany; i++)
      if (_progenitor instanceof LocatedAgent) {
        // Set coordinates within the birth area - randomly
        if (!Simulator.isChemostat) shuffleCoordinates(cc, _initArea);

        // Create the agent at these coordinates
        ((LocatedAgent) _progenitor).createNewAgent(cc);
      } else _progenitor.createNewAgent();

    LogFile.writeLog(
        howMany
            + " agents of species "
            + speciesName
            + " for one-time attachment successfully created");
  }
Ejemplo n.º 5
0
 /**
  * \brief Captures cell division by making a clone of this agent using the makeKid method
  *
  * <p>Captures cell division by making a clone of this agent using the makeKid method
  */
 public void divide() {
   try {
     // Create a daughter cell
     makeKid();
   } catch (CloneNotSupportedException e) {
     LogFile.writeLog("Error met in LocatedAgent.divide()");
   }
 }
Ejemplo n.º 6
0
  /**
   * \brief For self-attachment scenarios, initialises agents on the boundary layer rather than
   * substrarum, and models their swim to the surface or biofilm
   *
   * <p>For self-attachment scenarios, the agents are initialised at the top of the boundary layer
   * rather than on the substratum. These agents then perform a 'run and tumble' motion until they
   * either attach to the substratum or forming biofilm. This method captures this behaviour for
   * cells that are created for a time step. Once this swimming action has been performed, the agent
   * is created at its final position. Note that input of agents onto the boundary layer is decided
   * by a parameter set in the protocol file, cellAttachmentFrequency, measured in hours. The number
   * of cells is adjusted to suit the global time step that is being used. Also note that this
   * injection of cells can be for a set period (specified in the protocol file as parameter
   * cellInjectionPeriod), or can be stopped and started (modelling a 'settling' period) using
   * parameters cellInjectionOffPeriod and cellInjectionStopHour. This is explained in detail in the
   * tutorial for version 1.2 of iDynoMiCS.
   *
   * @param spRoot The Species markup from the protocol file for one particular species being
   *     initialised
   * @param numberAttachedInjectedAgents The number of agents of this type that need to be created
   *     in this global timestep
   */
  public void createBoundaryLayerPop(XMLParser spRoot, int numberAttachedInjectedAgents) {
    LogFile.writeLog(
        "\t\tAttempting to create "
            + numberAttachedInjectedAgents
            + " agents of "
            + speciesName
            + " in the boundary layer");
    // Create all the required agents

    // Note that this continues UNTIL THE DESIRED NUMBER OF CELLS HAVE ATTACHED SOMEWHERE
    // Just out of interest, I've decided to keep a count of how many cells are required for this to
    // happen
    int totalNumberOfInjectedAgents = 0;
    int agentsReturnedToBulk = 0;
    int requiredNumAttachedAgents = numberAttachedInjectedAgents;

    // Temporary DiscreteVector to make finding the boundary layer tidier.
    DiscreteVector dV = new DiscreteVector();

    while (numberAttachedInjectedAgents > 0) {
      totalNumberOfInjectedAgents++;

      if (_progenitor instanceof LocatedAgent) {
        swimmingAgentPosition.reset();

        // Now to choose coordinates for this particular agent
        while (true) {
          // This cell needs to take a random location in the Z and Y
          // directions. The X will come from the position of the
          // boundary layer on those axes. Generate these randomly.
          swimmingAgentPosition.y = ExtraMath.getUniRandDbl() * domain.length_Y;
          if (domain.is3D) {
            swimmingAgentPosition.z = ExtraMath.getUniRandDbl() * domain.length_Z;
          }
          // Now to work out the X coordinate. This is based on where
          // the top of the boundary layer is when this agent is
          // created. The top of the boundary layer is calculated in
          // Domain at each step. Now the resolution differs (this is
          // in nI x nJ x nK rather than microns - so this will need
          // to be converted accordingly. Method to calculate this:
          // - get the value from the top of the boundary layer
          // - reduce by 1 (such that the micron value will be the
          // 						 top of the layer)
          // - multiply by resolution of this domain.
          dV.set(swimmingAgentPosition, domain._resolution);
          if (!domain.is3D) dV.k = 1;
          swimmingAgentPosition.x = domain._topOfBoundaryLayer[dV.j][dV.k] - 1.0;

          swimmingAgentPosition.x *= domain._resolution;
          // Check this is ok.
          // System.out.println("Trying starting position "+dV.toString()+" =>
          // "+this.swimmingAgentPosition.toString());
          if (domain.testCrossedBoundary(swimmingAgentPosition) == null) break;
        }

        // Now we can do the run and tumble motion of these cells

        int cellRunResult = performRunAndTumble(spRoot);

        // If increment the relevant counters, as these may be useful
        switch (cellRunResult) {
          case 1: // Successfully Attached
            numberAttachedInjectedAgents--;
            // Create the agent at these coordinates
            ((LocatedAgent) _progenitor).createNewAgent(this.swimmingAgentPosition);
            // System.out.println("Cell "+swimmingAgentPosition.toString()+" attached");
            break;
          case 2:
            // System.out.println("Cell at "+swimmingAgentPosition.toString()+" returned to bulk");
            agentsReturnedToBulk++;
            break;
        }
      } else {
        // If this isn't a located species, just create a new agent.
        _progenitor.createNewAgent();
      }
    }
    // Write the stats to the log file incase of interest
    LogFile.writeLog(
        requiredNumAttachedAgents
            + " agents of species "
            + speciesName
            + " for self-attachment successfully created");
    LogFile.writeLog(
        totalNumberOfInjectedAgents + " agents of species " + speciesName + " attempted to attach");
    LogFile.writeLog(
        agentsReturnedToBulk + " agents of species " + speciesName + " returned to the bulk");
  }