Features that were new in previous Ptolemy II releases

Major Features that were new in Ptolemy II 7.0

SDF Code Generation

The SDF Template based C code generator (Codegen) generates code for hierarchical Synchronous Dataflow (SDF), Finite State Machine (FSM) and Heterochronous Dataflow Domain (HDF) models.

Codegen has the following new features:

($PTII/doc/codegen.htm, removed after ptII8.0, see $PTII/ptolemy/cg/README.html) Code Generator Documentation

References

Codegen Demonstrations

Some of the code generation demos might not work under Web Start because Web Start uses a JRE, not a JDK.

Primary Codegen Developers: Gang Zhou, Man-kit Leung.

Codegen Contributors: Christopher Brooks, Teale Fristoe, Edward A. Lee, Ye Zhou

 

Ptalon

Actor-oriented design is a common design strategy in embedded system design, where actors are concurrent components which communicate through ports by sending signals to one another. Such systems are frequently modeled with block diagrams, where the blocks represent systems and lines or arrows between blocks represent signals. Examples include Simulink, LabView, and VHDL/Verilog.

A common problem in such environments is managing complexity, particularly when the designs become large. Most actor-oriented design environments allow hierarchy, or systems (blocks) which are composed of other systems (blocks). To take this a step further, we are developing the Ptalon programming language, which allows users to parameterize components with other components.

We have developed a preliminary interpreter for the Ptalon language in the context of Ptolemy II, a general-purpose design environment for actor-oriented systems. We have also developed a mathematical framework for such languages, to help aid our understanding . We are currently investigating the resource management issues inherent in supporting large block-diagram models.

References

Ptalon Demonstrations

Backtracking

A backtracking facility enables the system to restore its old state. It has many applications in practice, and is especially important to high-performance distributed computation.

In developing this sub-project, we highlight the following (increasing) list of criteria:

Primary Developer: Thomas Huining Feng

Backtracking Demonstrations

The Continuous domain

The Continuous Domain is a redesign of the Continuous Time (CT) domain with a rigorous semantics documented in the following papers:

The continuous domain models systems with continuous dynamics, including for example analog circuits and mechanical systems, but also cleanly supports discrete events, modal behaviors, and signals that mix continuous-time behaviors with discrete events. Models for continuous dynamics are equivalent to linear or nonlinear integral equations. A sophisticated numerical solver for these equations is integrated with the director. The clean semantics of the Continuous domain enables its integration in hierarchical heterogeneous models that use the Synchronous/Reactive (SR) and Discrete Event (DE) domains. Arbitrary hierarchical mixtures of these domains are supported, although if SR is at the top level, then the period parameter of the director must be used so that time advances. Domain interactions are documented in the following paper:

Primary Developers: Haiyang Zheng, Edward A. Lee

 

Graph Transformation

The graph transformation facility provides a framework for the analysis and transformation of actor models using graph transformation techniques.

The design of large-scale models poses a number of challenges. As the size of the models increases to thousands of actors or hundreds of thousands of actors, analysis and consistent modification on the models become extremely hard. Furthermore, to maximize component reuse, a systematic approach is needed for the specification and maintenance of common patterns in the models and the transformation of those patterns.

The model transformation framework to be developed in this project aims to support the flexible specification of patterns and replacements by means of rules in graph grammar. An intuitive graphical user interface will be built. For novice users, a set of common transformations will be included in a library to facilitate their common tasks.

The transformations are models in their own right. They can be embedded in larger models hierarchically. Heterogeneous models of computation can be used to control the application of individual "atomic" transformations. This makes it easy to create sophisticated transformations by composing simple ones in a manageable and disciplined way. The sophisticated transformations will also take advantage of the concurrency inherent in those models of computation.

Model transformation can be applied as an optimization of modal models. These are hierarchical state machines with refinements in their states, which are sub-models to be executed when those states are active. The current implementation includes the complete description of each refinement in the model description, even though refinements of the states in a state machine tend to have large commonality. With the transformation technique, only one refinement needs to be stored completely. The others are obtained by transformations performed on the stored refinement. This eliminates redundancy and eases the job of modifying multiple refinements consistently.

Other applications of the model transformation technique include recognizing common design patterns in the models in a static analysis, replacing exiting design patterns with more efficient ones, and reusing design patterns by incorporating them into new models.

References

Graph Transformation Demonstrations

The Graph Transformation facility requires WebStart or a full installation, it will not work in an applet

Primary Graph Transformation Developer: Thomas Huining Feng

New demonstrations

Continuous Time (CT)

Discrete Event (DE)

Process Network (PN)

Synchronous Dataflow (SDF)

Synchronous/Reactive (SR)

User Interface Demonstrations

Other Key New Capabilities

ArrayType changes surrounding length

The ArrayType class now represents the length of arrays. New methods were added:
boolean hasKnownLength()
int length()
The length() method throws a RuntimeException if invoked on an ArrayType with hasKnownLength() == false.

Existing ArrayType instances (creating using the ArrayType(Type) constructor have unknown length. A new constructor ArrayType(Type, int) creates array types with a known length. Generally speaking, array types with known length are incomparable with array types with different lengths, and can be converted to an array type with unknown length and compatible element type. Scalars are convertible to array types with length 1. Getting the code to do this right was significantly more complex than inferring sizes of Fix-point types because:

  1. The FixType modifications were easily factored since any FixType with a known length is less than the single FixType with an unknown length. ArrayType could not be factored this way because of the more complex type relations.
  2. FixType doesn't have a contained type variable.
ArrayTypes now have a type construction functions: arrayType(int) and arrayType(int, 4) represent the types that you might expect.

Unfortunately, this means that there is a signficant backward-compatibility issue Previously, if you wanted to force an arbitrary integer array type, you used {int}, which is really an array with one element. This now has the type arrayType(int, 1), which is more specific than you probably want.

The existing models have been updated using the new description of an array type with an unknown length.

Note that arrayType(int) returns an instance of the special class UnsizedArrayToken, whose only purpose is to have an unknown array size. Regular array tokens always have a known length.

Note also that arrayType(unknown) is no longer the GLB of all of the arrayTypes. The GLB is now represented by BaseType.ARRAY_BOTTOM (which is not an instance of ArrayType). This required moving farther along the path of decoupling type constraints on array element types from the type objects themselves. TypeableElementTypeTerm can now refer to the element type of a typeable which may never esolve to a valid array type (resulting in an unsatisifed inequality term).

Primary Developer of ArrayType changes: Stephen Neuendorffer

New and Enhanced Actor Libraries

  • New Continuous Time (CT) actors:
  • New Synchronous Dataflow (SDF) actors:

    Additional Features

    New Code Generation Actors

    Bug fixes

    Backward Compatibility

    Most models developed under Ptolemy II 1.0.1, 2.0.1, 3.0.2, 4.0.1, 5.0.2 or HyVisual 2.2-beta, 3.0, 4.0.1, 5.0.1, 6.0.2 should run under Ptolemy II 7.0.1

    The MoMLParser includes a list of backward compatibility filters that make certain changes on models when read, handling such issues as actors being moved or renamed and parameter names being changed. The filters themselves are defined in ptolemy.moml.filter. If you have developed your own actors under earlier versions of Ptolemy II by writing your own Java files, you should recompile all your java code with the new release. In theory, copying the .class files should work, but recompiling is safer.

    Major Features that were new in Ptolemy II 6.0

    Other Key New Capabilities in 6.0

    New and Enhanced Actor Libraries in 6.0

    A number of new and enhanced actor libraries are included in version 6.0.2. You may also wish to refer to the ptolemy.actor.lib package, where most of the domain-polymorphic actors reside (domain-polymorphic actors are those that can be used in more than one domain).
  • New generic actors:
  • New Communicating Sequential Processes (CSP) actors:
  • New Discrete Event (DE) actors:

    New demonstrations in 6.0

    Additional Features in 6.0

    Major Features that were new in Ptolemy II 5.1

  • Viptos - an interface between TinyOS and Ptolemy II
  • Major Features that were new in Ptolemy II 5.0 Highlights

    Other Key New Capabilities

    New and Enhanced Actor Libraries

    A number of new and enhanced actor libraries are included in version 5.0. You may also wish to refer to the ptolemy.actor.lib package, where most of the domain-polymorphic actors reside (domain-polymorphic actors are those that can be used in more than one domain).

    New Demonstrations

    Major Features that are new in Ptolemy II 4.0

    Below are new features that were not present in Ptolemy II 3.x

    Other Features that are new in Ptolemy II 4.0

    New Demonstrations

    New and Enhanced Actor Libraries

    New Demonstrations of Older Capabilities

    Capabilities requiring additional software and/or hardware

    Additional Features

    New Actors

  • ptolemy.actor.lib
    ArrayAverage:
    (Mark Oliver, Edward A. Lee) An actor that outputs the average of the input array.
    ArrayLevelCrossing:
    (Edward A. Lee, Steve Neuendorffer) An actor that finds the index of the first item in an array to cross a specified threshold.
    ArrayPeakSearch:
    (Edward A. Lee) An actor that identifies peaks in an array.
    ArraySort:
    (Mark Oliver, Edward A. Lee) An actor that sorts the elements of an array.
    ArrayToElements:
    (Rachel Zhou) An actor that disassemble an ArrayToken to a multiport output.
    ComputeHistogram:
    (Steve Neuendorffer) Compute a histogram of input data.
    ElementsToArray:
    (Rachel Zhou) An actor that reads a token from each input channel to assemble an ArrayToken.
    Exec:
    (Christopher Hylands Brooks, Contributor: Edward A. Lee) Execute a command in a subprocess.
    Exit:
    (Edward A. Lee) A simple sink actor that consumes and discards input tokens and then calls System.exit() in wrapup.
    GradientAdaptiveLattice:
    (Steve Neuendorffer) An IIR filter actor that uses a direct form II implementation.
    SetVariable:
    (Edward A. Lee, Steve Neuendorffer) Set the value of a variable contained by the container.
  • ptolemy.actor.lib.comm
    Slicer:
    (Rachel Zhou) A Slicer, which functions as a decoder of the LineCoder of complex type.
    TrellisDecoder:
    (Rachel Zhou, contributor: Edward A. Lee) Decode convolutional code with non-antipodal constellation.
  • ptolemy.actor.lib.conversions
    StringToXML:
    (Yang Zhao) An actor that outputs data read from a URL.
  • ptolemy.actor.lib.hoc
    MobileFunction:
    (Yang Zhao) An actor that apply dynamically defined functions to its input.
    MobileModel:
    (Yang Zhao) A composite actor that apply models dynamically.
    ModelReference:
    (Edward A. Lee) An atomic actor that executes a model specified by a file or URL.
  • ptolemy.actor.lib.io
    DirectoryListing:
    ( Christopher Hylands, Edward A. Lee) An actor that produces an array that lists the contents of a directory.
  • ptolemy.actor.lib.jai
    AdaptiveMedian:
    (James Yeh) An actor that performs adaptive median filtering on a double matrix.
    ImageToJAI:
    (James Yeh) Convert an ImageToken to a JAIImageToken.
    JAIConstant:
    (James Yeh, Steve Neuendorffer) An actor that produces a JAIImageToken with constant bands.
    JAIDataConvert:
    (James Yeh) An actor that changes the data format in a JAIImageToken.
    JAIPNGWriter:
    (James Yeh) An actor that writes to a PNG file.
    SaltAndPepper:
    () package ptolemy.actor.lib.jai;
  • ptolemy.actor.lib.javasound
    LiveSoundActor:
    (Steve Neuendorffer) An actor that reads in audio samples and plays the audio data.
  • ptolemy.actor.lib.jmf
    AudioPlayer:
    (James Yeh) An actor that plays a DataSource containing a music file.
    ImageToJMF:
    (Christopher Hylands Brooks) Convert an ImageToken into a JMFImageToken.
    MovieReader:
    (James Yeh) An actor that outputs frames from a video file.
    MovieWriter:
    (James Yeh) An actor that writes frames to a video file.
    StreamLoader:
    (James Yeh) Load a datasource from a URL.
    VideoPlayer:
    (James Yeh) An actor that displays a AVI, Quicktime or MPEG video file.
  • ptolemy.actor.lib.security
    CipherActor:
    (Christopher Hylands Brooks, Contributor: Rakesh Reddy) A base class for actors that encrypt and decrypt data.
    CryptographyActor:
    (Christopher Hylands Brooks, Contributor: Rakesh Reddy) A base class for cryptographic actors.
    KeyReader:
    ( Christopher Hylands Brooks) Read in a keystore from a FileParameter and output a Key.
    KeyStoreActor:
    ( Christopher Hylands Brooks) A baseclass for actors that read or write keystores.
    KeyToken:
    (Christopher Hylands Brooks, Based on TestToken by Steve Neuendorffer) Tokens that contain java.security.Keys
    KeyWriter:
    ( Christopher Brooks) Read in a Key from the input port and write it out to a KeyStore.
    PrivateKeyReader:
    ( Christopher Hylands Brooks) Open a keystore from a FileParameter and output a PrivateKey.
    PublicKeyReader:
    ( Christopher Brooks) Open a keystore from a FileParameter and output a PublicKey.
    SecretKey:
    (Christopher Hylands Brooks, Contributor: Rakesh Reddy) Create a secret key and send it on the output.
    SecretKeyReader:
    ( Christopher Hylands Brooks) Open a keystore from a FileParameter and output a SecretKey.
    SignatureActor:
    (Christopher Hylands Brooks, Contributor: Rakesh Reddy) A base class for signature actors.
    SignatureSigner:
    (Christopher Hylands Brooks, Contributor: Rakesh Reddy) Sign the input data using a private key.
    SignatureVerifier:
    (Christopher Hylands Brooks, Contributor: Rakesh Reddy) Verify the signature of the input data.
    SymmetricDecryption:
    (Christopher Hylands Brooks, Contributor: Rakesh Reddy) Decrypt an unsigned byte array using a symmetric algorithm.
    SymmetricEncryption:
    (Christopher Hylands Brooks, Contributor: Rakesh Reddy) Encrypt an unsigned byte array using a symmetric algorithm.
  • ptolemy.actor.lib.string
    StringCompare:
    (Vinay Krishnan, Daniel L\341zaro Cuadrado (contributor: Edward A. Lee)) An actor that computes a specified String comparison function on the two String inputs.
    StringFunction:
    (Mike Kofi Okyere, Ismael M. Sarmiento) Trim a string, convert a string to uppercase, or convert a string to lowercase depending on the user's selection.
    StringIndexOf:
    (Rakesh Reddy, Philip Baldwin, Edward A. Lee) Finds index of a string contained in a given text
    StringLength:
    (Edward A. Lee) Output the length of a string provided at the input.
    StringMatches:
    (Antonio Yordan-Nones, Colin Cochran (contributor Edward A. Lee)) Pattern match a string to a regular expression.
    StringReplace:
    (Antonio Yordan-Nones, Neil E. Turner, Edward A. Lee) Replace an instance of a string with another input string according to a regular expression.
    StringSubstring:
    (Neil E. Turner and Edward A. Lee) Output a substring of the string provided at the input.
  • ptolemy.actor.lib.x10
    ApplianceController:
    (Colin Cochran (contributor: Edward A. Lee)) An ApplianceController actor sends x10-appliance-module commands to the x10 network.
    CommandListener:
    (Colin Cochran and Edward A. Lee) This actor senses specified X10 commands.
    LampController:
    (Colin Cochran and Edward A. Lee) A LampController actor sends X10-light-module commands to the X10 network.
    LevelListener:
    (Colin Cochran and Edward A. Lee) This actor senses specified X10 commands.
    Listener:
    (Colin Cochran (contributor: Edward A. Lee)) Output X10 commands detected on the X10 network.
    Receiver:
    (Colin Cochran and Edward A. Lee) Receive x10 commands propagating through an x10 network.
    Sender:
    (Colin Cochran (contributor: Edward A. Lee)) Send commands to an x10 network.
    X10Interface:
    (Colin Cochran and Edward A. Lee) This class creates an x10 inteface device which can send and receive 10 commands to and from an x10 network.
  • ptolemy.actor.lib.xslt
    XSLTransformer:
    ( Yang Zhao, Christopher Hylands Brooks) An actor that read an XSLT file and apply it to its input.
  • ptolemy.domains.gr.lib
    Box2D:
    (Steve Neuendorffer) A class that represents a 2D rectangle in a GR model.
    Ellipse2D:
    (Ismael M. Sarmiento, Steve Neuendorffer) Create a rectangle, rounded rectangle, or ellipse with the size and position specified by the user.
    FigureInteractor:
    (Ismael M. Sarmiento) Listen for and handle events on Diva figures.
    GRShape2D:
    (Steve Neuendorffer, Ismael M. Sarmiento) An abstract base class for shaded GR Actors
    GRTransform2D:
    (Steve Neuendorffer) An abstract base class for transforming input 3D shape
    IconViewScreen3D
    (Steve Neuendorffer) A GR scene viewer Removed between Ptolemy II 5.0 and 6.0 because it was unused and when it is in the configuration, it throws an exception because of icon problems)
    Image2D:
    (Ismael M. Sarmiento, Steve Neuendorffer) Create a figure from a user specified image file.
    Line2D:
    (Steve Neuendorffer, Ismael M. Sarmiento) Create a line with the endpoints provided by the user.
    Rectangle2D:
    (Ismael M. Sarmiento, Steve Neuendorffer) Create a rectangle, rounded rectangle, or ellipse with the size and position specified by the user.
    RectangularFigure2D:
    (Ismael M. Sarmiento, Steve Neuendorffer) Create a rectangle, rounded rectangle, or ellipse with the size and position specified by the user.
    Rotate2D:
    (Ismael M. Sarmiento, Steve Neuendorffer) Rotate a two-dimensional figure based on the angle and anchor point provided by the user.
    Scale2D:
    (Ismael M. Sarmiento, Steve Neuendorffer) Scale a two-dimensional figure based on the size provided by the user.
    Translate2D:
    (Steve Neuendorffer) An actor that translates the input 3D shape
    ViewScreen2D:
    (Steve Neuendorffer, Ismael M. Sarmiento) A GR scene viewer
  • ptolemy.domains.sdf.lib
    CountTrues:
    (Steve Neuendorffer) An actor that counts true inputs.
  • ptolemy.domains.sr.lib
    NonStrictTokenToExpression:
    (Haiyang Zheng) A non-strict actor that converts tokens into expressions. Removed because it is not a monotonic function.
  • ptolemy.vergil.actor.lib
    VisualModelReference:
    (Edward A. Lee) An atomic actor that executes a model specified by a file or URL.
  • Major Features that were new in Ptolemy 3.0

  • Continuous Time (CT) domain rework for improved mixed signal and hybrid systems semantics (Jie Liu, Parc, and Haiyang Zheng).
  • Component Interaction Domain (Yang Zhao, Xiaojun Liu) - The CI domain models systems that contain both data-driven and demand-driven styles of computation.
  • Rework of FSM domain to support chained transitions and better hybrid systems semantics (Haiyang Zheng).
  • Expression language rework to create a full-featured, functional and higher-order expression language with extensive support for composite types such as matrices, arrays, and records; the expression language is also now fully integrated with the Ptolemy II type system (Steve Neuendorffer, Edward A. Lee).
  • Configurations have been reworked to make it much easier to create standalone tools that extract portions of the Ptolemy II infrastructure and have customized user interfaces, documentation, and actor and director libraries. Configurations have been refactored into separate directories in $PTII/ptolemy/configs, and one example of such a standalone tool, HyVisual, is provided.
  • Updates to Vergil, the user interface for building models (Steve Neuendorffer, Edward A. Lee, John Reekie):
  • Run buttons on the toolbar and hotkeys.
  • Persistent window sizing and placement.
  • Undo/Redo.
  • Port Parameters.
  • vergil -help lists available configurations.
  • Full-screen mode for use in presentations.
  • Other user interface improvements (Steve Neuendorffer, Edward A. Lee):
  • Interactive shells infrastructure.
  • An interactive expression shell using this infrastructure.
  • Infrastructure for specialized token viewers. Files with the extension .ptd are now opened by a token viewer. The default token viewers is a text editor, but others can be added in the configuration.
  • A matrix token viewer.
  • HSIF Support (Haiyang Zheng). The Hybrid System Interchange Format (HSIF), was developed by the Institute of Software Integrated Systems (ISIS) at Vanderbilt University as part of the ISIS MoBIES effort. The HSIF documentation states: "The goal of HSIF is to define an interchange format for hybrid system models that can be shared between modeling and analysis tools. HSIF models represent dynamic systems, whose dynamics includes both continuous and discrete behaviors." Haiyang Zheng developed a set of XSLT files that convert HSIF into MoML, the XML format used to represent Ptolemy II Models. See the (../ptolemy/hsif/demo/index demo, Applets not well supported by Java after Ptolemy II 8.0).
  • A first version of higher-order components, the MultiInstanceComposite actor (Zoltan Kemenczy and Sean Simmons, Research In Motion, Ltd.). This actor creates a parameterized number of instances of a composite actor.
  • Python integration, with a PythonScript actor that permits definition of actors in Python (Xiaojun Liu). This uses Jython, a Java implementation of Python.
  • Other Features that are new in Ptolemy II 3.0

    New Demonstrations

  • CI: Component Interaction
  • Router
  • (../ptolemy/domains/ct/doc/body.htm): CT: Continuous Time
  • (../ptolemy/domains/ct/demo/ComparedClocks/ComparedClocks.xml) Compared Clocks
  • (Old demo: ptolemy/matlab/demo/MatlabCT/MatlabCT.xml) Matlab Continuous Time Demonstration
  • HSIF Thermostat and Swimming Pool
    This example shows a simple thermostat modeled as a hybrid system. The purpose of the example is to demonstrate the ability that HyVisual has to import models defined in HSIF, the Hybrid System Interchange Format. To run HSIF models, you must invoke Ptolemy II with the -hyvisual command line argument or else run the HyVisual Web Edition. These models will not work in a standard Ptolemy II vergil or Web Edition because to support HSIF, we need to check xml each file to see if it is an HSIF file of a MoML file. This check slows Ptolemy II down slightly.
    See the (../ptolemy/hsif/demo/index demo, Applets not well supported by Java after Ptolemy II 8.0) for details.
  • HSIF Swimming Pool.
    This example shows a simple hybrid system model of a pool.
  • (../ptolemy/domains/ct/demo/LevelCrossingDetector/LevelCrossingDetector.xml) Level Crossing Detector
  • (../ptolemy/domains/ct/demo/SampledClocks/SampledClocks.xml) Sampled Clocks
  • DE: Discrete Event
  • HOC DE (New in Ptolemy II 3.0.2)
  • FSM: Finite State Machine (Removed between Ptolemy II 8.0 and 10.0)
  • Chained Transitions
  • Modal Binary Symmetric Channel
  • State Tracker
  • SDF: Synchronous Dataflow
  • DFT Subset
  • Fourier Series
  • Sound Spectrum
  • New Actors

    Changes between Ptolemy II 3.0.1 and 3.0.2

    Ptolemy II 3.0.1 was an interim release with a narrow distribution.
    The following changes occurred between 3.0.1 and 3.0.2

    Actors that were added between Ptolemy II 3.0.1 and 3.0.2

    ArrayMaximum
    (Mark Oliver) Extract maximum element from an array.
    ArrayMinimum
    (Mark Oliver, Edward A. Lee) Extract minimum element from an array.

    Enhancements between Ptolemy II 3.0.1 and 3.0.2

    $PTII/configure.in, $PTII/configure, $PTII/.classpath.in, $PTII/.eclipse.epf, $PTII/configs/FindClass.java
    Support for configuring Eclipse.

    Bug Fixes between Ptolemy II 3.0.1 and 3.0.2

    ptolemy/domains/sdf/lib/vq/ImageSequence.java
    Adjusted initial value of imageURLTemplate parameter
    ptolemy/domains/sdf/lib/Autocorrelation.java
    Can now handle complex data.
    lib/saxon7.jar Updated to 7.6.5 of Saxon. This was necessary to get both the HSIF demos and the Cal demos to work.
    ptolemy/vergil/actor/ActorEditorGraphController.java
    Under MacOS look and feel, use Command-Click to create new relations and drag new edges
    ptolemy/vergil/toolbox/PtolemyTransferable.java
    Under MacOS look and feel, change how we instantiate the DataFlavor so as to avoid a stack trace
    ptolemy/actor/gui/TextEffigy.java
    If the user tries to open a missing file, throw a better exception.

    Major Features that are new in Ptolemy 2.0

  • (../ptolemy/domains/de/demo/ModalModel/ModalModel demo, Applets not well supported by Java after Ptolemy II 8.0) (Xiaojun Liu, Edward A. Lee)
    A model model is one whose behavior depends on its "mode" of operation. A modal model in Ptolemy II is an FSM (finite state machine) combined hierarchically with other models. A state in the FSM represents a mode of operation, and can have a refinement that gives the behavior in that model. The refinement can be another FSM or some other model using some other Ptolemy domain. This example combines DE, FSM, and SDF to model a system where regularly sampled signals are perturbed by irregular events in time.
  • ($PTII/doc/codegen.htm, removed after ptII8.0, see $PTII/ptolemy/cg/README.html) Code Generator Documentation (Primary Author: Stephen Neuendorffer, Contributor: Christopher Hylands)
    This release includes a limited prototype of our code generation facility that will generate .class files for non-hierarchical SDF models.
    Note that the code generator will not work in an applet, but will work with Web Start, the Windows installer and the standard configure and build.
  • ptolemy.data.unit - (../ptolemy/data/unit/demo/Units/Units demo, Applets not well supported by Java after Ptolemy II 8.0) (Primary Authors: Yuhong Xiong, Xiaojun Liu, Contributors: Winthrop Williams, Edward A. Lee)
    A major source of errors in embedded software is incorrect application of units. Yuhong Xiong and Xiaojun Liu have created a unit system for Ptolemy II that is quite clever. A suite of constants are defined, with names such as "meter", "cm", "feet", "miles", "seconds", "hours", and "days". In each unit category ("length" or "time" for example), there is a primary unit with respect to which all the others are specified. Thus, for example, if the primary unit of length is meters, then the expression "1.0 * cm" will have an internal value of 0.01 * meters. Compound units are specified by just multiplying and dividing, as in for example "1.0 * cm/second".

    The way this is realized is that these unit constants are tokens just like other Ptolemy II data, and multiplication and division are overloaded in the base classes for numeric valued tokens. We continue to work on this architecture to enable users to customize the unit system on a per-model basis.

  • Timed Multitasking Domain (Jie Liu) - an implementation of a model of computation based on priority-driven multitasking, as common in real-time operating systems (RTOSs), but with more deterministic behavior.
  • Synchronous/Reactive Domain: (Primary Author: Paul Whitaker, Contributors: Elaine Cheong, John Reekie)
  • Web Start (Christopher Hylands) - Ptolemy II includes support to build distributions using Sun's Web Start facility, which allows end users to download fully functional distributions via the web.
  • Vergil updates (Steve Neuendorffer, Edward A. Lee, John Reekie) Vergil has been improved and the following features have been added
  • Annotations - It is now much easier to annotate a model with text.
  • Parameters - The model can display top level parameter names and values
  • Snap to grid - It is now much easier to line up actors
  • Panner, zoom - The panner and zoom facilities make it easier to navigate large
  • Improved FSM editor
  • Animation - It is now possible to show which actors are firing when.
  • Better icons - Some icons such as Const, Scale and Expression will display their values.
  • Set data types of ports
  • Java Virtual Machine properties window - JVM Properties can be queried and garbage collection requested.
  • (../ptolemy/domains/ct/doc/signal_types.htm) Documentation for setting CT signal types
  • See $PTII/doc/design/usingVergil/index.htm for more complete information
  • Other Features that are new in Ptolemy II 2.0

    New Demonstrations

  • (../ptolemy/domains/ct/doc/body.htm): CT: Continuous Time
  • (../ptolemy/domains/ct/demo/BouncingBall) Bouncing Ball (Requires Java 3D, see the GR domain) A Continuous Time model that uses a Finite State Machine and the GR domain to simulate a bouncing ball.
  • (../ptolemy/domains/ct/demo/CarTracking) Car Tracking A following car tracking a leading car in an unreliable communication environment.
  • (../ptolemy/domains/ct/demo/Switch) Switching Continuous Signals Shows how to handle hybrid systems with both continuous and discrete inputs and outputs.
  • (../ptolemy/domains/ct/demo/Thermostat) Modal Thermostat A thermostat model where the refinements of the modes in the state machine are the same model.
  • (../ptolemy/data/unit/demo/Units/Units demo, Applets not well supported by Java after Ptolemy II 8.0) A demonstration of the Units facility.
  • DE: Discrete Event
  • (../ptolemy/domains/de/demo/ModalModel/ModalModel demo, Applets not well supported by Java after Ptolemy II 8.0) This example combines DE, FSM, and SDF to model a system where regularly sampled signals are perturbed by irregular events in time.
  • FSM: Finite State Machine (Removed between Ptolemy II 8.0 and 10.0)
  • (http://ptolemy.eecs.berkeley.edu/ptolemyII/ptII8.0/ptII/ptolemy/domains/fsm/demo/Blending/Blending demo, Applets not well supported by Java after Ptolemy II 8.0) A blending controller with two major control modes.
  • (http://ptolemy.eecs.berkeley.edu/ptolemyII/ptII8.0/ptII/ptolemy/domains/fsm/demo/MultipleRuns/MultipleRuns demo, Applets not well supported by Java after Ptolemy II 8.0) A state machine performs multiple runs of the refinement of mode1.
  • Giotto: Synchronous Periodic Systems
  • (../ptolemy/domains/giotto/demo/Composite/Composite demo, Applets not well supported by Java after Ptolemy II 8.0) A composite demo with a Giotto model embedded in a DE model.
  • GR: 3-D graphics (experimental)
  • (../ptolemy/domains/gr/demo/FurutaPendulum/FurutaPendulum demo, Applets not well supported by Java after Ptolemy II 8.0) The Furuta pendulum has a motor controlling the angle of an arm, from which a free-swinging pendulum hangs. The objective is to swing the pendulum up and then balance it.
  • SDF: Synchronous Dataflow
  • (../ptolemy/domains/sdf/demo/LMSAdaptive/LMSAdaptive demo, Applets not well supported by Java after Ptolemy II 8.0) An adaptive filter.
  • (../ptolemy/domains/sdf/demo/MaximumEntropySpectrum/MaximumEntropySpectrum demo, Applets not well supported by Java after Ptolemy II 8.0) A spectral estimation example.
  • SR: Synchronous/Reactive (experimental)
  • (../ptolemy/domains/sr/demo/TokenRing/TokenRing demo, Applets not well supported by Java after Ptolemy II 8.0) A cyclic token-ring arbiter composed of three blocks.
  • TM: Timed Multitasking (experimental).
  • (../ptolemy/domains/tm/demo/Controllers/Controllers demo, Applets not well supported by Java after Ptolemy II 8.0) Two (independent) control loops whose controllers share the same CPU.
  • (../ptolemy/domains/tm/demo/FFT/FFT demo, Applets not well supported by Java after Ptolemy II 8.0) This model shows the use of background process for long running tasks in the TM domain.
  • (../ptolemy/domains/tm/demo/MergedEvents/MergedEvents demo, Applets not well supported by Java after Ptolemy II 8.0)
  • (../ptolemy/domains/tm/demo/SimpleTasks/SimpleTasks demo, Applets not well supported by Java after Ptolemy II 8.0) This model shows two independent tasks on a single CPU machine.
  • New Actors

    Major Features that were new in Ptolemy II 1.0.1

  • Vergil - the Ptolemy II GUI (Steve Neuendorffer and Edward A. Lee)
  • Giotto Domain (Christoph M. Kirsch, Benjamin Horowitz, Thomas A. Henzinger)
  • Java 3D Domain (GR Domain) (Chamberlain Fong)
  • Discrete Time Domain (Chamberlain Fong)
  • CORBA/Jini work (Jie Liu)
  • Other Features that were new in Ptolemy II 1.0.1

    Last Updated: $Date: 2014-12-01 19:30:22 -0800 (Mon, 01 Dec 2014) $