Ptolemy II 7.0.1 Release Notes

Ptolemy II is a set of Java packages supporting heterogeneous, concurrent modeling and design. Its kernel package supports clustered hierarchical graphs, which are collections of entities and relations between those entities. Its actor package extends the kernel so that entities have functionality and can communicate via the relations. Its domains extend the actor package by imposing models of computation on the interaction between entities. Examples of models of computation include discrete-event systems, dataflow, process networks, synchronous/reactive systems, and communicating sequential processes.

Ptolemy II includes a number of support packages, such as
data, providing a type system, data encapsulation and an expression parser,
plot, providing visual display of data,
math, providing matrix and vector math and signal processing functions, and
graph, providing graph-theoretic manipulations.

The three volumes of the Ptolemy II Design Document describes the Ptolemy II design and the implementation of the Java classes.

The "Using Vergil" describes how to use Vergil.

Complete List of Domains in Ptolemy II

Platforms

The core of Ptolemy II 7.0.1 is 100% Java, so it should work on any platform that has JDK 1.5 or later.

We developed Ptolemy II 7.0.1 under Solaris 10 and Windows XP and with JDK1.5.0.0_14

Ptolemy II 5.0 will not compile under Java 1.3 because we use the java.lang.URI class, which is present only in Java 1.4 and later. JDK 1.5 or later is required so that these packages can use generics: backtrack, ptalon and others.

Ptolemy II has been compiled and run under IBM JDK 1.6.0. There are the following limitations under IBM JDK 1.6.0

  • The Copernicus code generator does not work.
  • Caltrop does not work.
  • The IBM JDK seems to return directory contents in a different order than the Sun JDK. Thus actor.lib.io.DirectoryListing might return elements in a different order.
  • Contents:

    Ptolemy II 7.0.1 Highlights

    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:

    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.

    Features that were new in previous Ptolemy II releases

    Features that were new in previous Ptolemy II releases

    Limitations

    Version 7.0.1 has the following limitations:

    Release Limitations

    • The gzipped tar file of Ptolemy II source files with Unix line endings (ptII7.0.1.src.tar.gz) requires GNU tar or WinZip. Solaris 2.5.1 tar will fail to untar this file with a checksum error because the pathnames are longer than 100 characters.

      Note further that some of the .class names are longer than 31 characters, which may cause problems when downloading zip files on the Macintosh and using Stuffit.

    • The documentation for custom actors used in demonstrations is not included in the release. The source code for the custom actors can be found in the source download.
    • If a URL ends with #in_browser, then Ptolemy II will invoke the User's web browser. Unfortunately, this does not always work, especially under Windows if Netscape is already running. The workaround is to exit Netscape and let Ptolemy II start up Netscape for you.
    • Web Start does not work very well if the pathname to the vergil.jnlp file has spaces in it. The workaround is to place your Ptolemy II tree in a directory that does not have spaces in the path name if you plan on using Web Start.
    • If your user library contains actors that are not present in vergil, then you may see a dialog or dialogs asking if you want to skip these elements. This could happen if you had developed custom actors and put them into your user library and these custom actors are not present in the release. The work around is to click 'Skip Element' and continue with the start up.
    • Applet issues:
      • We've experienced problems with the browser freezing when between applets. What happens is that the previous applet gets a InterruptedException and pops up a modal dialog box, which freezed the browser. We are working on a solution.
      • Applets do not correctly display the TextAttribute, DocumentationAttribute or the TM "Show schedule" icon.
      • The Ptolemy II Applets require java 1.4.1_02 or later so as to prevent problems with Windows XP and Radeon displays that causes XP to hang when a Java application is exiting. For details, see http://developer.java.sun.com/developer/bugParade/bugs/4713003.html
        For non-applet situations, we can invoke the browser with -Dsun.java2d.d3d=false or -Dsun.java2d.noddraw=true, but for applets we must require Java 1.4.1_02 or later.
        As a result, the applet html code requires version 1.4.2 or later,
      • Applets seem to run out of memory after about 82Mb.
      • There are no Jython or Cal applets
      • Opera has problems viewing applets that are on the local file system. In particular, it seems to have problems with urls like file:///d|/ptII/ptolemy/plot/demo/FourierSeries.htm which work fine in Netscape 4.x, IE, Mozilla.

        However, if I use the following style of URL, then some of the applets work: file://localhost/d:/ptII/ptolemy/plot/demo/FourierSeries.htm. Unfortunately any applet that accesses a data file will not work with the above URL style because the data file will be outside the codebase.

        The solution is to install a web server on the local machine and view the applets using http://localhost/

      • Opera 6.03/Windows 2000/Java 1.4.0, may have problems running applets that include diva.jar if diva.jar is not downloaded in the first applet. To reproduce this problem:
        1. Run SDF Butterfly, which does not use diva.jar
        2. SDF Expression, which uses diva.jar
        3. In Opera, do Window -> Special -> Java Console, and you will see the following stack trace
          java.lang.NoClassDefFoundError: diva/graph/GraphController	
          at java.lang.Class.getDeclaredConstructors0(Native Method)  
          at java.lang.Class.privateGetDeclaredConstructors(Class.java:1576) 
          at java.lang.Class.getConstructor0(Class.java:1748) 
          at java.lang.Class.newInstance0(Class.java:266)  
          at java.lang.Class.newInstance(Class.java:249) 
          at opera.PluginPanel.run(opera/PluginPanel.java:343) 
          at java.lang.Thread.run(Thread.java:536)  
          
        The problem only occurs under Opera.
      • Running the Networked demo via an applet on the local file system results in an AccessControlException.
        com.microstar.htm.htmException: XML element "entity" triggers exception:
          java.lang.Exception: Attempted to lookup 'Waveform', but got: 
          java.lang.ClassNotFoundException: Waveform
        Attempted to find as a moml class, but got: 
                     java.security.AccessControlException: access denied
                     (java.net.SocketPermission ptolemy.eecs.berkeley.edu resolve)
        	     in file:/C:/Program Files/Ptolemy/Ptolemy II 3.0 beta2/
                           ptolemy/moml/demo/Networked/ at line 62 and column 118
        	at ptolemy.moml.MoMLParser.startElement(MoMLParser.java:1341)
        	at com.microstar.htm.htmParser.parseElement(XmlParser.java:944)
        	at com.microstar.htm.htmParser.parseContent(XmlParser.java:1117)
        	at com.microstar.htm.htmParser.parseElement(XmlParser.java:946)
        	at com.microstar.htm.htmParser.parseDocument(XmlParser.java:495)
        	at com.microstar.htm.htmParser.doParse(XmlParser.java:175)
        	at com.microstar.htm.htmParser.parse(XmlParser.java:145)
        	at ptolemy.moml.MoMLParser.parse(MoMLParser.java:492)
        	at ptolemy.moml.MoMLParser.parse(MoMLParser.java:471)
        	at ptolemy.moml.MoMLParser.parse(MoMLParser.java:456)
        	at ptolemy.actor.gui.MoMLApplet._createModel(MoMLApplet.java:188)
        
        The Network demo does not work as a local applet because the xml file includes a reference to http://ptolemy.eecs.berkeley.edu, which is not on the local file system, so we get a SecurityException.
        The workaround is to run the applet by downloading it from the Ptolemy Website: http://ptolemy.eecs.berkeley.edu/ptolemyII/ptII7.0/ptII/ptolemy/moml/demo/Networked/Networked.htm
      • If an icon file is not present, then a Vergil applet might try to download the icon file multiple times. Ptolemy II uses XML files to store icons. For example $PTII/ptolemy/actor/lib/BooleanSwitchIcon.xml is an icon for $PTII/ptolemy/actor/lib/BooleanSwitch.java
        The problem is that if an actor does not have an icon file, then the applet may go back to the server multiple times looking for the icon.
    • Windows Installer Issues:
      • Sometimes running a model that uses the Matlab interface will cause Ptolemy II to exit. Usually this occurs if Vergil has been running for a while and then the Matlab interface is loaded.
        Workaround #1: Run a model that uses the Matlab interface as the first model by doing Quick Tour -> Matlab CT.
        Workaround #2: We believe that the problem has to do with loading the Direct Draw library. http://developer.java.sun.com/developer/bugParade/bugs/4838939.html suggests invoking java with -Dsun.java2d.noddraw=true.
        The way to do this is to edit vergil-full.lax and add the line
        lax.nl.java.option.additional=-Dsun.java2d.noddraw=true	
        
        which we went ahead and did. Note that because of problems with Radeon displays, setting noddraw to true is not such a bad idea. See above for details.
        The way to check if this argument is being used is to hold down the Control key and double click on the vergil-full.exe icon.
        You should see something like:
        	
        c:\j2sdk1.4.2\bin\java.exe -Dsun.java2d.noddraw=true com.zerog.lax.LAX C:\\Ptol
        emy\\Ptolemy_II_7.0ptiny\\vergil-ptiny.lax C:\\DOCUME~1\\cxh\\LOCALS~1\\Temp
        \\env.prop
        executing java...
                
        Note that to debug the binary, you would use the following line:
        lax.nl.java.option.additional=-Xdebug -Xrunjdwp:transport=dt_shmem,server=y,suspend=n 
                
      • The Windows installer works best if you are in the Administrators Windows group. Otherwise, the Windows installer tends to dump lots of icons on your desktop
    • Web Start issues:
      • The Matlab Wireless demo fails under Web Start. The problem is that the Matlab .m file cannot be found.
      • The Python Ptolemizer demo does not work under Web Start, probably because Jython cannot handle loading classes from the Ptolemy II classes.
      • The JAI Adaptive Median model does not work under Web Start - the repaired image might be corrupt. The reason is that it uses the JAI acceleration libraries, which Web Start does not load.
      • Viewing a pdf file may bring up a blank window along with the pdf file. Running the code generator may bring up a blank window while the java or javac processes are running.
      • Some of the links on the GR domain instructions page might not work under Web Start because the files they refer to are not present.
    • Limitations in demonstrations
      • CT CarTracking should be run using View->Run so that the user can change the fault parameter.
      • HTVQ demo: The displays do not go away when the demo is exited.
      • GR demos: Under Java 3D 1.3.1-beta, the ViewScreen actor may display a black image when a second GR demo is run.
        The workaround is to install Java 3D 1.2.1_04.
      • Bouncer demo: If the user drags the bouncing icon, it no longer bounces

    Limitations in the Class Mechanism

    The class mechanism is highly preliminary and is likely to change in future releases. There are several known problems:
    • Several higher-order-components will not work inside class definitions. (ModalModel, several CT actors, etc.).
    • Name collisions can occur when adding objects to base classes whose names collide with objects in derived classes. Auto naming should look through the derivedList for name conflicts.
    • Propagation of changes to a base class is very slow in Vergil. If there are more than just a very few instances or derived classes, interactive editing is not practical. As a workaround, put the class definitions in a separate file and edit them without opening the model that creates instances. The probable reason is that MoMLParser handles propagation by issuing large numbers of change requests.
    • Certain actors, such as MathFunction, change the number of ports when parameters change. This violates the derivation invariance for classes. To demonstrate the bug, put a MathFunction actor in a base class that has a subclass. Change the function parameter in the subclass to anything but "modulo". Then change the function in the base class to "modulo" (which adds a port). Now attempt to insert a parameter into the port. You will get an InternalErrorException when it tries to propagate the change.

    Limitations in the Actor Libraries

    • The actor library is far from complete.
    • The Expression actor does not properly propagate type constraints in an expression-dependent fashion. It works correctly for double-valued expressions of double-valued inputs.
    • The Ptolemy parameter parser uses comma "," to separate elements in an array. This causes problems when Ptolemy is run on European machines that use a comma "1,0" instead of a period "1.1" in floating point numbers.
    • The Display actor uses the Swing JTextArea component which is known to have memory leaks.
    • The readFile() parameter function does not work with applets. Instead, use readResource().
    • The Matlab interface works only under Windows and it requires that Matlab be installed on the local machine. The Matlab interface should work with version of Matlab from R11 (5.3) and up to and including R13 (6.5)

      Didier Mauuary reports that under Windows 98, configure failed to set up the MATLAB_DIR, PTCC and PTDLLTOOL makefile variables, but after he set them by hand:

       MATLAB_DIR = /cygdrive/c/MATLABR11
       PTCC = gcc
       PTDLLTOOL = dlltool
      
      he was able to get farther with the recompilation of the Matlab interface.
    • Under Windows, the Matlab interface has problems at runtime with gcc-3.3.
      Under Windows, we recommend using gcc-3.2, or Microsoft Visual C.
    • Under Windows, Matlab models sometimes cause Ptolemy to exit the second time the model is run!
      The problem seems to be a segfault within a Windows library. The problem only affects systems where Matlab is compiled with Microsoft Visual C.
    • The actor.lib.comm.SerialComm actor requires that Javacomm is installed http://java.sun.com/products/javacomm/index.html. The SerialComm actor will only work under Windows.
    • IterateOverArray has the following problems
    • IterateOverArray: When you drop in an actor, and then another actor, and then select "undo," the second actor is deleted without the first one being re-created. Thus, undo is only a partial undo. The fix to this is extremely complicated. Probably the only viable mechanism is to use UndoStackAttribute.getUndoInfo() to get the undo stack and then to manipulate the contents of that stack directly.
    • IterateOverArray: There should be an option to reset between firings of the inside actor.
    • IterateOverArray: If you drop a new actor onto an IterateOverArray in a subclass, it will simply acquire the new contents, but not actually do anything with them. It should somehow refuse to accept the new object in the subclass, since to do so, it would have to delete the original object defined in the base class, and this would violate the derived invariant.
    • IterateOverArray: If an instance of IterateOverArray in a derived class has overridden values of parameters, those are lost if contained entity of the instance in the base class is replaced and then an undo is requested.
    • IterateOverArray: When an actor with a display icon like Const, Expression, or MathFunction is put into IterateOverArray, the CopyCatIcon doesn't reflect the text display.

    Limitations in the PN Domain

    The PN domain documents that it locally handles mutations. However, this is currently not true in the implementation. For the basic PN model, this doesn't really matter, since mutations happen pretty much the same as they would otherwise. (i.e. they are non-deterministic in when they execute) However, for timed PN models, there is actually some expressiveness lost, since timed PN models can locally execute mutations deterministically.

    Embedding a PN typed composite actor inside a non-process top level such as DE does not work. In fact embedding a process domain inside a non-process domain is likely to have problems. Profess Lee wrote:

    Yes, it looks as if the code is designed so that process domains (PN, CSP) can only be used within process domains. I'm not sure to what extent this is a limitation of the process domains vs. a semantic problem. What would PN mean within DE? Since PN has no well-defined notion of a "firing", how would you assign time stamps to the outputs of a PN actor? By default in DE, the time stamps of the outputs of an actor match those of the inputs that triggered the firing. There is no such notion in PN.

    Limitations in the User Interface

    Below are some of the limitations of Vergil, the Ptolemy II Graphical User Interface.
    • The labeling of ports gets messed up if you change cardinality.
    • Cancelling a style change doesn't restore original state. There are FIXME's about this in actor.gui.style.StyleConfigurer.
    • If there are multiple windows open for a model, say, the top level vergil window and the tree view, or the top level window and the inside look of a composite component, when the top level window is closed, all other windows are closed, but the user is not prompted to save any change to the model.
    • When setting the type of a port, we should provide a combo box that lists the common ports
    • When creating a Modal Model, use Control-Right-Button to drawn arcs between nodes. One potential workaround would be to have an information message in the status bar about this.
    • You should not change the names of built in ports - The port mechanism should disallow port name changes on ports that are named in Java. The UI could recognize this. The UI should not allow the user to remove built in Java defined ports.
    • Manually setting of the types of actors like ArrayToSequence that have constraints on their element types can cause problems.
    • HTVQ demo is badly laid out when run under vergil.
    • Weak support for multiports in the graph editor.
    • It is difficult to control wire routing.
    • Cannot have more than one vertex in a connection.
    • No mechanism to set the width of a relation.
    • The integrated web browser is not a full-featured browser.
    • Debugger not yet integrated.
    • It is difficult to add actors to the libraries.
    • No dynamic class reloading.
    • Plot windows don't resize when control panel is resized
      If a model with plotters is executed using the run button on the toolbar, and then re-executed using the run control panel accessed through the View menu, then resizing the run control panel does not cause the plots to resize to fit.
      Workaround: Close the model and re-open it, and then run first using the run control panel.
    • There is no mechanism in the UI to save a model as a class, nor to save a submodel as a class.
    • There is no mechanism in the UI to create a custom icon for a library element and store it in the right place.
    • If an actor uses a slider, then the actor tree navigator pane incorrectly shows the slider as a subitem of the actor.
    • It seems that if you close a model that has been modified, get prompted to save it, and select save, then the model is saved but not closed. It should be closed too...
    • When I select a large number of items from one model, and copy and paste them into a new one, they sometimes all get placed at the origin. Strangely, if I then auto-place, and then undo, they get their original (correct) placement!
    • Printing a model that contains transparent objects can result in problems when printing to Encapsulated Postscript (EPS).
      If a model has transparent objects, then when it is printed to EPS, the resulting file is a bitmap instead of a Postscript description of the graphics. You can tell by the file size (several Meg vs. several K) and by opening it in Illustrator, where in theory you should be able to ungroup and select and edit individual components.
      The way Java prints EPS is that there is an implementation of Graphics2D that literally translates each graphics2D call into a Postscript snippet. If Java detects any transparent colors or images, then the literal translation of each element independently doesn't work, so the printing code reverts to writing everything to an image and then sending the image, encapsulated in Postscript to the printer.
      Solution1: Use one of these pdf writing programs to generate pdf-1.4 compliant pdf files, which have extensions to support transparency that Postscript lacks, and then print them to eps, which would use the distill implementation of the above algorithm. Or alternatively, we could switch to using pdftex instead of latex->dvips->distill which should embed pdf for figures directly at the expense of less robust latex support. http://www.geocities.com/marcoschmidt.geo/java-libraries-pdf.html
      Solution 2: Use the undocumented flag -Dsun.java2d.print.pipeline=pdl on the command line to force the printing to use the postscript path, ignoring transparency. Under Cygwin:
      export JAVAFLAGS=-Dsun.java2d.print.pipeline=pdl
      vergil
      
      Then edit the file by hand in Illustrator to add the transparency back in.

    Limitations in JNI

  • The Interface to C actors using the Java Native Interface is not available via the Windows Installer (or Web Start). To use the JNI/Ptolemy II interface, you must download Ptolemy II as source files and compile.
  • The JNI user interface was removed between Ptolemy II 4.0 and Ptolemy II 7.0 because the UI stopped working.
  • Code Generation Limitations

    Code Generation limitations are covered on the Code Generation page.

    Missing Domains

    • Boolean and integer dataflow.

    For limitations discovered after the release, see the Ptolemy II 7.0.1 website

    Last Updated: $Date: 2008/04/04 18:04:31 $