Package com.amalgamasimulation.discreterate

Class Tank<T>

java.lang.Object
com.amalgamasimulation.discreterate.FlowElement<T>
com.amalgamasimulation.discreterate.Tank<T>
Type Parameters:
T - type (class or interface) whose instances represent materials
public final class Tank<T> extends FlowElement<T>
Tank is a flow element that can store materials.

Tank can have at most one inflow connection and at most one outflow connection.

Max storage capacity of a Tank is defined during its construction and may also be changed later.

Inside a Tank, several material mix portions can coexist in a form of a sequence. Each such portion is called a 'Layer' and is represented by an instance of Tank<T>.Layer class. Materials from different layers are separated, but layers can be mixed into one layer (see mix() method).

Layers are ordered according to the FIFO rule: the 1st portion of material mix that was added to the Tank becomes the 1st portion of material mix to be exported. Layers can be requested by the getLayers() method that returns the Tank's layers sorted, the first Layer being the most recently added Layer and the last Layer representing the Layer ready to export its material mix from the Tank.

  • Constructor Details

    • Tank

      public Tank(FlowEnvironment<T> flowEnvironment, double capacity)
      Creates a new Tank instance.
      Parameters:
      flowEnvironment - FlowEnvironment which this Tank belongs to
      capacity - tank storage capacity

    • Tank

      public Tank(FlowEnvironment<T> flowEnvironment, String name, double capacity)
      Creates a new Tank instance.
      Parameters:
      flowEnvironment - FlowEnvironment which this Tank belongs to
      name - tank name
      capacity - tank storage capacity

  • Method Details

    • addFullHandler

      public void addFullHandler(Consumer<Tank<T>> handler)
      Adds an action that will be executed every time this Tank becomes full.
      Parameters:
      handler - action that will be executed every time the Tank becomes full
      See Also:

    • removeFullHandler

      public void removeFullHandler(Consumer<Tank<T>> handler)
      Removes the previously added full Tank action.
      Parameters:
      handler - previously added full Tank action
      See Also:

    • addEmptyHandler

      public void addEmptyHandler(Consumer<Tank<T>> handler)
      Adds an action that will be executed every time this Tank becomes empty.
      Parameters:
      handler - action that will be executed every time the Tank becomes empty
      See Also:

    • removeEmptyHandler

      public void removeEmptyHandler(Consumer<Tank<T>> handler)
      Removes the previously added empty Tank action.
      Parameters:
      handler - previously added empty Tank action
      See Also:

    • addInflowRateChangedHandler

      public void addInflowRateChangedHandler(Consumer<Tank<T>> handler)
      Adds an action that will be executed every time the inflow rate changes.
      Parameters:
      handler - action that will be executed every time the inflow rate changes
      See Also:

    • removeInflowRateChangedHandler

      public void removeInflowRateChangedHandler(Consumer<Tank<T>> handler)
      Removes the previously added inflow rate change handler.
      Parameters:
      handler - previously added inflow rate change handler
      See Also:

    • addOutflowRateChangedHandler

      public void addOutflowRateChangedHandler(Consumer<Tank<T>> handler)
      Adds an action that will be executed every time the outflow rate changes.
      Parameters:
      handler - action that will be executed every time the outflow rate changes
      See Also:

    • removeOutflowRateChangedHandler

      public void removeOutflowRateChangedHandler(Consumer<Tank<T>> handler)
      Removes the previously added outflow rate change handler.
      Parameters:
      handler - previously added outflow rate change handler
      See Also:

    • setCapacity

      public void setCapacity(double newCapacity)
      Sets the storage capacity of this Tank.
      Parameters:
      newCapacity - new storage capacity of the Tank, must be non-negative

    • getCapacity

      public double getCapacity()
      Returns the storage capacity of the Tank.
      Returns:
      storage capacity of the Tank

    • getFillingRate

      public double getFillingRate()
      Returns the difference between the input rate and the output rate. May be negative.
      Returns:
      difference between the input rate and the output rate

    • getContentsAmount

      public double getContentsAmount()
      Description copied from class: FlowElement
      Returns the total quantity of all materials inside this flow element.
      Specified by:
      getContentsAmount in class FlowElement<T>
      Returns:
      current sum of all material quantities inside this flow element
      See Also:

    • getAnimationContentsAmount

      public double getAnimationContentsAmount()
      Returns the total quantity of all materials inside this flow element.

      This method must be called from animation when it is needed to determine quantity of all materials. Calling getContentsAmount() from animation might result in non-reproducibility of the model.

      Returns:
      current sum of all material quantities inside this flow element
      See Also:

    • isFull

      public boolean isFull()
      Indicates that this Tank is full.
      Returns:
      true if the Tank is full, false otherwise

    • isEmpty

      public boolean isEmpty()
      Indicates that this Tank is empty.
      Returns:
      true if that at the tank is empty, false otherwise

    • checkForRecalculation

      protected void checkForRecalculation()

    • getConstraints

      protected List<org.apache.commons.math3.optim.linear.LinearConstraint> getConstraints(com.amalgamasimulation.discreterate.LPArea<T> lpArea)

    • getInflowRate

      public double getInflowRate()
      Description copied from class: FlowElement
      Returns the current flow rate of all materials at the input of this flow element.
      Specified by:
      getInflowRate in class FlowElement<T>
      Returns:
      current flow rate of all materials at this flow element's input
      See Also:

    • getOutflowRate

      public double getOutflowRate()
      Description copied from class: FlowElement
      Returns the current flow rate at the output of this flow element.
      Specified by:
      getOutflowRate in class FlowElement<T>
      Returns:
      current flow rate at the output of this flow element
      See Also:

    • getTotalInflowAmount

      public double getTotalInflowAmount()
      Description copied from class: FlowElement
      Returns the total amount of all materials that have entered this flow element.
      Specified by:
      getTotalInflowAmount in class FlowElement<T>
      Returns:
      total amount of all arrived materials

    • getTotalOutflowAmount

      public double getTotalOutflowAmount()
      Description copied from class: FlowElement
      Returns the total quantity of materials that have left this flow element.
      Specified by:
      getTotalOutflowAmount in class FlowElement<T>
      Returns:
      total quantity of exported materials
      See Also:

    • addThreshold

      public Tank.Threshold addThreshold(double threshold, Runnable activity)
      Adds an action that will be executed every time the amount of material in this Tank hits the provided threshold value during simulation.

      The 'threshold hit event' will be fired only if the threshold is reached during simulation, as a result of modeling the material flow. Specifically, manually changing the contents of the flow element (via replaceContents(Accumulator) method, for example) will NOT trigger the event. If this method is invoked (even during simulation) with the threshold value equal to the current amount of material inside the Tank, this will not trigger a 'threshold hit event' either.

      Reaching the threshold value either from below and from above will trigger the 'threshold hit event'.

      The event will be fired each time the threshold is reached (i.e. it is not a one-time handler).

      Parameters:
      threshold - the material amount threshold value in this flow element
      activity - action that will be executed when the amount of material inside this flow element reaches the threshold
      Returns:
      a new Tank.Threshold, description of the added threshold

    • removeThreshold

      public void removeThreshold(Tank.Threshold threshold)
      Removes threshold action added by the addThreshold(double, Runnable) method.
      Parameters:
      threshold - description that was returned by the addThreshold(double, Runnable) method

    • clearThresholds

      public void clearThresholds()
      Removes all threshold actions added by the addThreshold(double, Runnable) method.

    • getLayers

      public List<Tank<T>.Layer> getLayers()
      Returns the unmodifiable list of all Tank<T>.Layers contained inside this Tank.

      Layers are sorted from element's entrance to element's exit: the first layer in the list is the most recently added layer, and the last layer is the layer that is the closest to the Tank's exit.

      Returns:
      unmodifiable list of all Tank<T>.Layers contained inside this Tank

    • mix

      public void mix()
      Combines all layers of materials in this Tank into a single layer.

      The set of materials in the resulting Tank<T>.Layer is formed by unique material in all initial layers. The amount of each material in the resulting layer is the sum of amounts of that material in all initial layers.

    • swapContents

      public void swapContents(Tank<T> tank)
      Swaps the contents of this flow element with the contents of tank Tank element.
      Parameters:
      tank - tank whose contents must be swap with contents of this flow element
      See Also:

    • replaceContents

      public void replaceContents(Accumulator<T> newContents)
      Replaces the contents of this Tank with the newContents Accumulator.

      If the amount of material in newContents is positive, the Tank will contain a single Tank<T>.Layer. Otherwise, the Tank will have no layers.

      Parameters:
      newContents - an Accumulator instance with new contents of the Tank
      See Also:

    • replaceContents

      public void replaceContents(T material, double amount)
      Replaces the contents of this Tank with amount quantity of material material.

      If the amount of material is positive, the Tank will contain a single Tank<T>.Layer. Otherwise, the Tank will have no layers.

      Parameters:
      material - material
      amount - amount of the material
      See Also:

    • replaceContents

      public void replaceContents(List<Accumulator<T>> listOfLayers)
      Removes all materials from this Tank and sets its internal layers of materials to the listOfLayers. The Tank<T>.Layers in the listOfLayers should be sorted: the 1st layer is near the Tank's entrance, and the last is next to the the Tank's exit.

      Layers from listOfLayers with zero or negative amount of material are ignored.

      Parameters:
      listOfLayers - new layers of the Tank
      Throws:
      IllegalArgumentException - if total amount of materials in listOfLayers exceeds the current storage capacity of this Tank, or if total amount of materials in listOfLayers is less than 0.
      See Also:

    • addContents

      public void addContents(Accumulator<T> addedContents)
      Adds the contents of the addedContents Accumulator to this Tank.

      If the total amount of materials in addedContents is positive, a new tank Tank<T>.Layer is created. The layer's contents will match the addedContents. The created layer will be the 'topmost' layer in the Tank, i.e., the layer closest to the Tank's 'input' and the first layer in the list returned by the getLayers() method.

      If the total amount of materials in addedContents is 0, no new layer is added.

      Parameters:
      addedContents - materials and their amounts to be added to this Tank
      Throws:
      IllegalArgumentException - if total amount of materials in addedContents is less than 0
      IllegalArgumentException - if the sum of the current material amount in the Tank and the amount of added contents exceeds the storage capacity of this Tank

    • getContentsDescriptor

      public Accumulator<T> getContentsDescriptor()
      Description copied from class: FlowElement
      Returns all materials contained inside this flow element as an instance of Accumulator.

      Each element of the Accumulator matches the amount of the corresponding material inside this flow element. The sum of amounts of materials in the Accumulator instance is equal to the value returned by the FlowElement.getContentsAmount() method.

      Specified by:
      getContentsDescriptor in class FlowElement<T>
      Returns:
      Accumulator containing all materials inside the flow element
      See Also:

    • getAnimationContentsDescriptor

      public Accumulator<T> getAnimationContentsDescriptor()
      Returns all materials contained inside this flow element as an instance of Accumulator.

      Each element of the Accumulator matches the amount of the corresponding material inside this flow element. The sum of amounts of materials in the Accumulator instance is equal to the value returned by the getContentsAmount() method.

      This method must be called from animation when it is needed to determine all materials inside this flow element as an instance of Accumulator. Calling getContentsDescriptor() from animation might result in non-reproducibility of the model.

      Returns:
      Accumulator containing all materials inside the flow element
      See Also:

    • getContentsAmount

      public double getContentsAmount(T material)
      Description copied from class: FlowElement
      Returns the current quantity of the specified material inside this flow element.
      Specified by:
      getContentsAmount in class FlowElement<T>
      Parameters:
      material - material
      Returns:
      current quantity of the specified material inside this flow element
      See Also:

    • getInflowRateDescriptor

      public Accumulator<T> getInflowRateDescriptor()
      Description copied from class: FlowElement
      Returns an Accumulator instance that describes the flow rate at the input of this flow element.

      The returned Accumulator instance contains the respective rates of all materials currently entering the flow element. The sum of values in the Accumulator is equal to 1.

      Specified by:
      getInflowRateDescriptor in class FlowElement<T>
      Returns:
      descriptor of the current inflow rate
      See Also:

    • getOutflowRateDescriptor

      public Accumulator<T> getOutflowRateDescriptor()
      Description copied from class: FlowElement
      Returns an Accumulator instance that describes the flow rate at the output of this flow element.

      The returned Accumulator instance contains the respective rates of all materials currently leaving the flow element. The sum of values in the Accumulator is equal to 1.

      Specified by:
      getOutflowRateDescriptor in class FlowElement<T>
      Returns:
      descriptor of the current outflow rate
      See Also:

    • getOutflowRateProportions

      public Accumulator<T> getOutflowRateProportions(FlowConnection<T> outflowConnection)
      Description copied from class: FlowElement
      Returns an Accumulator instance that contains flow rate proportions of materials exported through the outflowConnection outflow connection.

      Each element of the returned Accumulator corresponds to a material in the current material flow of outflowConnection. The value of each element in the Accumulator is the ratio of the rate of that material's partial flow to the overall flow rate of outflowConnection. The sum of values in the Accumulator is equal to 1.

      Specified by:
      getOutflowRateProportions in class FlowElement<T>
      Parameters:
      outflowConnection - an outflow connection
      Returns:
      material proportions in the outflow connection

    • getTotalInflowAmount

      public double getTotalInflowAmount(T material)
      Description copied from class: FlowElement
      Returns the total amount of the specified material that has entered this flow element.
      Specified by:
      getTotalInflowAmount in class FlowElement<T>
      Parameters:
      material - material
      Returns:
      total amount of the specified material that has arrived to this flow element
      See Also:

    • getTotalInflowDescriptor

      public Accumulator<T> getTotalInflowDescriptor()
      Description copied from class: FlowElement
      Returns an Accumulator instance that contains the total quantity of each material that has entered this flow element.

      The values of each element in the returned Accumulator match the quantities of the respective materials that have entered the flow element. The sum of values in the Accumulator is equal to the value returned by the FlowElement.getTotalInflowAmount() method.

      Specified by:
      getTotalInflowDescriptor in class FlowElement<T>
      Returns:
      Accumulator containing total amounts of materials that have entered this flow element
      See Also:

    • getTotalOutflowAmount

      public double getTotalOutflowAmount(T material)
      Description copied from class: FlowElement
      Returns the total quantity of the specified material that has left this flow element.
      Specified by:
      getTotalOutflowAmount in class FlowElement<T>
      Parameters:
      material - material
      Returns:
      total quantity of the specified material that has left this flow element
      See Also:

    • getTotalOutflowDescriptor

      public Accumulator<T> getTotalOutflowDescriptor()
      Description copied from class: FlowElement
      Returns an Accumulator instance that holds the total amounts of each material that has left this flow element.

      The values of each element in the returned Accumulator match the quantities of the respective materials that have left the flow element. The sum of values in the Accumulator is equal to the value returned by the FlowElement.getTotalOutflowAmount() method.

      Specified by:
      getTotalOutflowDescriptor in class FlowElement<T>
      Returns:
      Accumulator containing total amounts of materials that have left this flow element
      See Also:

    • getRelativeContentsAmount

      public double getRelativeContentsAmount()
      Returns the relative fullness of this Tank. Calculated as the ratio of the current contents amount to the capacity.
      Returns:
      relative fullness of this Tank
      See Also: