Package ptolemy.domains.de.lib

Class TimeCompare

  • All Implemented Interfaces:
    java.lang.Cloneable, Actor, Executable, FiringsRecordable, Initializable, SequenceActor, TimedActor, TypedActor, Changeable, Debuggable, DebugListener, Derivable, Instantiable, ModelErrorHandler, MoMLExportable, Moveable, Nameable
    public class TimeCompare
extends DEActor
    A DE actor to compare the time stamps of events at its two input ports, and output the difference. Every time an event can be processed either at input port input1 or at input2, the event is consumed. The value that the event carries is insignificant, but the time stamp of the event is recorded in a local list. Time stamps received at the two input ports are stored in two different lists. Every time when both lists have data, the difference between the top elements of the lists is obtained, and is sent to the output port. This done by subtracting the time stamp of every top event in the list for input2 with the time stamp of every top event in the list for input1.

    This actor could potentially consume an infinite amount of memory if the arrival rates of events at the two input ports are different, because one of the lists keeps growing.

    Since:
    Ptolemy II 8.0
    Version:
    $Id$
    Author:
    Thomas Huining Feng
    Pt.AcceptedRating:
    Red (tfeng)
    Pt.ProposedRating:
    Red (tfeng)

    • Field Detail

      • input1

        public TypedIOPort input1
        The first input port.

      • input2

        public TypedIOPort input2
        The second input port.

      • nonnegative

        public Parameter nonnegative
        A boolean parameter to decide whether inputs at input2 should be ignored if they lead to negative outputs.

      • output

        public TypedIOPort output
        The output port to which difference values are sent.

    • Constructor Detail

      • TimeCompare

        public TimeCompare​(CompositeEntity container,
                   java.lang.String name)
            throws NameDuplicationException,
                   IllegalActionException
        Construct an actor with the specified container and name. This is protected because there is no reason to create an instance of this class, but derived classes will want to invoke the constructor of the superclass.
        Parameters:
        container - The container.
        name - The name.
        Throws:
        IllegalActionException - If the entity cannot be contained by the proposed container.
        NameDuplicationException - If the container already has an actor with this name.

    • Method Detail

      • clone

        public java.lang.Object clone​(Workspace workspace)
                       throws java.lang.CloneNotSupportedException
        Clone this actor into the specified workspace. The new actor is not added to the directory of that workspace (you must do this yourself if you want it there). The result is a new actor with the same ports as the original, but no connections and no container. A container must be set before much can be done with this actor.
        Overrides:
        clone in class TypedAtomicActor
        Parameters:
        workspace - The workspace for the cloned object.
        Returns:
        A new ComponentEntity.
        Throws:
        java.lang.CloneNotSupportedException - If cloned ports cannot have as their container the cloned entity (this should not occur), or if one of the attributes cannot be cloned.
        See Also:
        NamedObj.exportMoML(Writer, int, String), NamedObj.setDeferringChangeRequests(boolean)

      • fire

        public void fire()
          throws IllegalActionException
        Fire this actor once. If there are events at its input ports, they are immediately consumed, and their time stamps are recorded in a list. If the two internal lists for the two input signals both have data, then outputs are sent to the output port, which are the difference between the time stamps in the two lists.
        Specified by:
        fire in interface Executable
        Overrides:
        fire in class AtomicActor<TypedIOPort>
        Throws:
        IllegalActionException - If thrown when trying to consume input events or produce output events.

      • prefire

        public boolean prefire()
                throws IllegalActionException
        Return ture if this actor can fire. This actor can fire if prefire() of the superclass returns true, and either of the two input ports, or both, have token.
        Specified by:
        prefire in interface Executable
        Overrides:
        prefire in class AtomicActor<TypedIOPort>
        Returns:
        true if this actor can fire.
        Throws:
        IllegalActionException - If thrown when trying to decide whether the input ports have token or not.