Denis Dube 
Masters Student
Modelling, Simulation and Design Lab
School of Computer Science
McGill University
McConnell Engineering bldg. room 202
3480 University Street
Montreal, Quebec
Canada H3A 2A7
office:
home:
e-mail:
www:
YahooIM:
+1 (514) 398-7071 ext 0364
+1 (450) 616-9082
denkkar@gmail.com
msdl.cs.mcgill.ca/people/denis
PHOTO
   

Final Update?

I graduated and started working at the MathWorks on Sept. 29, 2006. I very much enjoy working there, not least because I get to play around with yet more GUI's. All contact information above should be considered null and invalid. My address is currently:

1296 Worcester Rd. Apt. 2407 (pronounced Worster in that New England accent)
Framingham, MA, USA 
01702

Cell: Five-Oh-Eight Eight-One-Six Three-Oh-Six-Oh
Office: Five-Oh-Eight Six-Four-Seven Eight-Oh-Six-One

AToM3 Download Area

Download AToM3 (Build Feb. 13, 2007) , Additional AToM3 files, and Recent Changes List

AToM3 Documentation

AToM3 installation readme (txt), and AToM3 Help Guide (HTML but old)

Illustrated AToM3 Tutorials (HTML Format, Updated: Sept. 5, 2006): Basic, Advanced Graph Grammars


M.Sc. thesis (final): Graph Layout for Domain-Specific Modeling and some AToM3 Automatic Layout Pictures


If you have problems with AToM3 e-mail denkkar@gmail.com and watch the recent change list)

What is AToM3?

Official answer, main AToM3 page

It's a tool that lets you make an editor for models... fast. Instead of building a whole application, you just specify what can be connected to what, what they look like, and what attributes they aught to have (such as names or number of tokens).

Sound like just any other drawing tool? Well it's not! Once you've specified the type of models you want to draw, you can draw just that kind of model, so you won't insert inconsistent elements into it like you could in a general drawing tool. Moreover, AToM3 takes care of details like placing arrows nicely, and offers a good selection of automatic layout tools so you don't waste time prettying up your diagrams.

In case you were wondering, the multi-formalism part of AToM3 means that if you specifying two types of models (lets call these formalisms), then you can draw a model containg components from both simultaneously. Throw in graph grammars, and this gets much more interesting, as you can use these grammars to transform one type of model into another. AToM3 lets you specify these grammars in a mostly visual fashion (specifying exactly what happens to attributes tends to involve code), and even lets you automatically generate latex documentation of the entire grammar.

Where do I come into the picture? Well, basically AToM3 was stone-age in the user-interface department ( see AToM3 version 0.2.2 if you don't believe me). So I pretty much changed the entire GUI, modeled the reactive behaviour parts of it and generated the code from this model that is used AToM3 0.3, implemented all the layouting algorithms, latex documentor, added menus, help messages, debugging info, and fixed bugs and inconsistent behaviour.

Can anyone use AToM3? Well, you actually need to read the guide (not that it's terribly complete), to figure out how to use it. Knowledge of Python (programming language in which AToM3 is implemented) is not needed for low-level use of AToM3 but as soon as you want condition/action code, or better yet a code generator, you'll feel the need for brushing up on Python.

Logo done entirely in AToM3 using 5-6 formalisms at once

Extra stuff for AToM3

Download AToM3 external utility pack: LPSolve, SVM, and yED

About:

These "external" utilities add extra functionality to AToM3. They only need to be installed once since they do not change (unlike the main AToM3 distribution).

LPSolve is used for solving linear programming problems.

SVM is especially important if you plan on using statecharts in AToM3, since this utility is responsible for simulating and generating code.

yED is used when the best quality layout of a model is desired. In this case the model graphics are exported to yED which then does the layout. The model can then be re-imported into AToM3 (i.e., the position, height, and width info). Note that the arrows tend to have slightly incorrect offsets when re-importing though.

Installation instructions:

The simplist method to install them is to place the external utility folders in your User area (this is created the first time AToM3 is started) in the 'User_External' directory. You can also place them arbitrarily, but then you'll have to edit the ExternalUserPaths.py file to point to it.

AToM3 Recent ChangeList: Updated Sep 1, 2006

  • Modifed the uniqueFormalismNamer.py to be more effective and added the correct usage of it to the advanced tutorial (i.e.: to re-name an entire formalism for re-use purposes).
  • Added a big warning in the basic tutorial with regards to the correct directory for putting formalisms in.
  • -- Sep 1, 2006
  • Fixed bug in graph grammar editor when top menubar is enabled in the options.
  • Debug console now prints a traceback when commands result in an exception.
  • -- Aug 30, 2006
  • Improved the Debug Console to make it useable! It is now possible to type either "self" or "atom3i" to get an instance of ATOM3 and then trigger an incredible number of methods directly during run-time. The console can now be re-sized. If your code crashes, the console can now handle it. If you exit AToM3, the debug console no longer causes exceptions (that would force you to control-break).
  • Improved the error dialog encountered when AToM3 cannot find a meta-model
  • Fixed bug in the Advanced Modelling Tutorial (a picture showed the "EDIT" instead of "SELECT" trigger)
  • -- Aug 29, 2006
  • Added a GG tutorial.
  • Re-designed the UI for modifying Graph Grammar rules. Instead of having to click on a button to edit the LHS and then the RHS, both sides of the rule are shown in the same dialog with the "Name", "Order", etc. of the rule. Better yet, the dialog window (for the rule) has full support for re-sizing as well as scrollbars.
  • Modified the UI for the primary Graph Grammar editing dialog.
  • Added an "Isolate Association" button, to make getting an association without the entities it is normally connected to, easy.
  • Fixed bugs in the Graph Grammar that were causing "Subtype Matching" not to work.
  • -- Aug 25, 2006
  • Fixed bug in Icon Editor introduced when I added Font sorting.
  • -- Aug 18, 2006
  • Modified the code generator for CD_ClassDiagramsV3 formalism. Associations are now inherited by subclasses from their superclass.
  • Modified the code generator for CD_ClassDiagramsV3 formalism. Error messages given for classes without a visual representation have been streamlined so you only get hit once with a dialog. Note: if a class has no visual representation, attempting to instantiate it (such as by pushing the corresponding button in the generated formalism) will result in an exception. Perhaps a default icon should be provided?
  • Modified the error dialog shown when a formalism is not in the correct directory. It should now be absolutely clear where the formalism should be.
  • -- Aug 15, 2006
  • Added a C++ STL layout server Win32 executable and a Python pipe that make it useable within AToM3 by pressing the HOME key. Implemented: Spring, Tree-like, FTA, Circle, and Random (the last 2 are useful in conjunction with Spring). The speed increase in porting the Python implementations to C++ are over 2 orders of magnitude, but don't quote me on that, I ran a very skimpy benchmark.
  • Fixed some bugs in Tree-like layout under some graphs and added a new tip-over style tree layout.
  • Fixed bugs in the custom type model code generator
  • Fixed SVG exporter so it always exports unique "id" tags for each item.
  • -- Aug 12, 2006
  • SVG exporter: improved text anchor support by exhaustive tweaking
    View the exported text test: AllTextAnchorsTest.svg (SVG capable browser needed)
  • SVG exporter: added support for the "Image" primitive
    View the exported primitives test: AllPrimitivesTest.svg (SVG capable browser needed)
  • -- June 21, 2006
  • Implemented a SVG (Scalable Vector Graphic) exporter (works on any AToM3 model loaded on the canvas). It is accessible via the Postscript exporter.
  • Added a small Digital Watch formalism to demonstrate scoped UI event handling.
  • Modified the scoped UI event handler to better deal with statechart event locks.
  • Improved DChartsV3 formalism layout behaviour.
  • Fixed more bugs in the DChartsV3 formalism code generator (All the constructs, except priorities, have now been tested in compiled code).
  • Added one-click layouting buttons to the CD_ClassDiagramsV3 formalism.
  • -- June 19, 2006
  • Improved the formalism-specific buttons... formalism. Currently used in conjunction with DChartsV3. Combines behaviour statecharts and layout (layered drawing technique) very naturally.
  • Fixed bugs in the new DChartsV3 formalism code generator. Since the DChartsV3 formalism is bootstrapped using itself, the formalism itself was previously buggy due to incorrect code generation.
  • -- May 10, 2006
  • Added DChartsV3 formalism to the distribution. Simulation and code generation are working.
  • Fixed bugs in the automatic layout interface module with hyperedges or with directed edges that are upgraded to hyperedges.
  • -- May 10, 2006
  • Fixed bugs related to starting AToM3 with no default meta-model. The bugs caused the model menu and the types list not to display.
  • -- Apr 5, 2006
  • Added a new scaling and dragging user-interface layer. Should be more intuitive.
  • Modified a number of things, including addition of a method to show/hide links.
  • Updated FAQ
  • -- Apr 3, 2006
  • Fixed a data-structure bug in Hierarchical layout that was causing graphs with many cycles (and hence reversed edges) to be layed out incorrectly.
  • Fixed a bug in graphLink.py when dealing with a link that has arrows in both directions.
  • Modified the cardinality dialog to be user-friendly instead of doing the exact opposite of what one would expect...
  • -- Feb 11, 2006
  • Modified ATOM3Text type so that you can set the height of a text box and it will stay that height after you save/load a model with an entity which has an attribute of the ATOM3Text type. No more tiny text windows!!!
  • Modified the exception logger to log files in the user options area (.AToM3)
    This was neccessary for central installations of AToM3
  • Updated main AToM3 options. Removed obsolete stuff.
    AToM3 no longer starts with formalisms open unless the USER asks for them.
  • Updated atom3/FAQ.txt
  • -- Feb 10, 2006
  • Re-built the Class Diagram formalism. It is now called CD_classDiagramsV3.
    NOTE: I did not make it the default yet, so you'll have to either manually load it or set it up in AToM3 options to load when you start.
  • Class diagram attributes now propagate from superclasses to subclasses instantly after editing.
    The method employed is simple but robust.
    Derived attributes are internally marked so they are never confused with normal attributes.
    The derived attributes are consistent under load/save cycles.
    They are also consistent under any changes made to the inheritance structure. (so long as Edit and Disconnect/Connect triggers report said changes, might be a problem in graph grammar situations?)
    SIDE-EFFECT: All attributes are now alphabetically sorted by name
  • Graphical icons are propagated from superclasses to subclasses if the subclass has no icon of it's own.
  • I killed the buttons grammar system. It annoyed me for the last time.
    (1) It was a gross miss-use of a grammar system
    (2) With no model-evolution capabilities it had a huge PITA factor
    Therefore I'm sure you'll all appreciate my new system... (works for all generative meta-models without any changes!)
  • Updated atom3/FAQ.txt
  • -- Feb 4, 2006
  • Modified the core event handler loop to take into account that Tkinter is multi-threaded and may suddenly stop handling one event to start working on another event while the first event isn't done executing yet.
  • Added some postaction "create" triggers. In particular, meta-models with that register for the create postaction trigger will now recieve it when loading transformations! Hopefully all hell won't break loose... but I had to do this because some formalisms need their initilization routines triggered by this!
  • Added an animated move method to graphEntity.py, allows for linear or acceleration based movement. Assuming self is a semantic object, and you want to move to pixel coordinates x=100, y=100, use it as follows: self.graphObject_.animatedMoveTo((100, 100), acceleration=9.8)) or self.graphObject_.animatedMoveTo((100, 100), timeSecInt=4)) to do the linear movement in 4 seconds. NOTE: acceleration method does not allow you to determine the time the animation takes. The animation ends when the entity has moved to the target location.
  • Added some new methods to GraphicalForm.py for more Tkinter canvas manipulation power.
  • Updated atom3/FAQ.txt
  • -- Feb 2, 2006
  • Improved all automatic layout algorithms. Layouters are accessible through the regular layout menu (shortcut key... L).
    Layouter specific shortcuts are shown in the layout menu.
    Improvements are made in terms of layout quality, convergence speed, code simplicity, and an additional sub-algorithm for crossing minimization.
  • Added ability to turn all invisible links orange. Press Control-6.
    Should be especially useful for those poor people trying to write visual graph grammars with invisible links...
  • Added extra command-line functionality.
    Command help and ability to load models (not just meta-models) directly from the command-line.
  • Added external scripting functionality.
    This allows you to run AToM3 via a script and no user-intervention.
    Perfect for batch testing... see atom3/scriptedAToM3.py
  • Updated atom3/FAQ.txt
  • -- Jan 25, 2006
  • Numerous changes to the graph grammar system (and I don't remember them all). Added help messages, debug messages, changed the latex documentation generator to give more info for Specify, to scale the LHS and RHS drawings properly, and to use GG labels that are visible to the naked eye!
  • Changed the way low level user interface events are handled.
  • Massively overhauled the automatic layout algorithms. The old algorithms still exist and are untouched for compatiblity reasons. The new ones all work through a common interface to AToM3 (so they don't know about AToM3 and AToM3 does not know about them). Spring layout actually converges! The hierarchical crossing reducer actually works non-randomly! Access to these improved layout algorithms is currently through the HOME key, until inspiration strikes me.
  • Added some random bugs... just joking. We really need a version control system at MSDL though...
  • -- Nov 25
  • Added ability to turn specify code on/off in a graph grammar RHS rule.
  • -- Aug 31
  • Rolled back the GGRule.py found in the Aug 19 version of AToM3. Was causing extremely nasty bugs in graph grammars. This means super-ugly layout during GG execution once again.
  • Redid all the keybindings, moving towards a scoped UI environment.
  • Added all the new layouts to the layout menu.
  • Added an uninstall script to make fixing your AToM3 installation easier.
  • -- Aug 30
  • Fixed arrow connected to arrow drawing problems.
  • Added a shift-delete binding to delete an entity but not the arrows it is connected to. This allows you to create partially connected arrows in graph grammars.
  • Added Copy LHS error handler
  • -- Aug 19
  • Added "template code" when creating new graph grammar rules, so that you don't have to hunt down for the arcane bits of code neccessary for making a graph grammar.
  • Added automatic sorting of graph grammar rules by their "Order" attribute.
  • Added a duplicate GG label checker that nabs duplicates immediately
  • Updated the version of Causal Block Diagrams in the distribution
  • Added a warning if attempting to generate a formalism from a meta-model (ie: with Entity Relationships) when multiple meta-models are opened (As Ernest discovered, it won't work properly).
  • Modified the generator for Class Diagrams V3, will now work even with multiple formalisms open :)
  • Improved the Model Menu a bit, should work better when multiple-formalisms are open and you want to use it to drop stuff not in the toolbar buttons. Still very very shaky though... and impossible to improve further without re-generating all older formalisms (speaking of which, formalisms from before 2004 will undoubtedly not show up on the menu at all).
  • Modified the "Generate code" item in the Model Menu. Will now show a warning to the effect that you should use the "Generate" button in the toolbar instead.
  • Made it possible to enable/disable actions and conditions in grammars.
  • -- Aug 11
  • Improved startup behaviour when AToM3 is run for the first time.
  • Added a dialog to the icon editor that warns if a visual icon has no connectors, thus saving the unwary meta-modeller the agony of not knowing why arrows are failing to connect
  • Improved the behaviour of the code generator for both ER and Class Diagram formalisms in the event that no name has been given to the metamodel. (These last 3 changes brought to my attention by Ernesto)
  • Improved arrow creation code so that it is now possible to create formalisms where edges can themselves contain connection points in their center drawing, thus making it possible to connect an edge in a grammar with a generic edge...
  • It is now possible to save a visual icon that contains only a connector, such as for the center object of an edge. (These last 2 changes brought to my attention by Sagar)
  • Added a dialog when AToM3 is closed that asks the user if they want to trash all the temporary files that have accumulated (if the temporary files have not been automatically deleted already... this happens when AToM3 crashes).
  • -- Aug 8
  • Added new error messages to the graph grammar re-writing system to make debugging easier. (Brought to my attention by Sagar)
  • Improved graph grammar transfromation visualization. Previously transformations resulted in randomly placed nodes. Now they are placed near the nodes they connect to. I can't do much better than this without requiring graph grammar authors to input quite a bit of layout specification.
  • Improved automatic arrow optimizations to handle self-looping links.
  • Improved named port support by adding messages that tell you want named port you started your arrow at and terminated your arrow at. Can also be disabled easily if you don't like dialog windows...
  • Fixed arrow optimizer issues with named ports
  • Fixed arrow editor issues with named ports
  • QOCA layout is now possible, though disabled by default. Uses are limited to very specific diagrams... unfortunately QOCA simply doesn't have that much power for general layout, and even worse, does not hybridize well with other layout techniques.
  • Added simple circle layout, operates on entire graph or selection
  • Added tree-like layout, operates on entire graph or selection
  • Added hieararchical layout, operates on entire graph or selection, very powerful. Works well on most diagram types, although Causal Block Diagrams don't look very natural with it. They would need Orthogonal layout...
  • NOTE: new layouts are not in the Layout Menu yet in this release. If you wish to test them, try "Control-X" where X is in the range 1 <= X <= 6
  • -- Aug 4
  • Added QOCA incremental linear constraint support for graphical layout. This is disabled by default in the main options. Do not use yet, still changing things...
  • Fixed a bug in the graphical entity easyScale() method
  • Disabled option database locking. Can now run multiple copies of AToM3 at once with no popup messages :)
  • -- July 7
  • Fixed a bug with the GEN button for Class Diagrams version 3 (did not work properly if you did not specify all the visual icons first).
  • Experimented with timed StateCharts and AToM3. Polling worked but was far too slow, especially when dragging multiple objects. Instead used a comprimise solution: events are handled as they come in (unless an event is already being handled, then it is queued and executed right after, fixing nastiness that used to occur in the old version), and timed events are triggered by a polling mechanism that depends on Tkinter after method. The Central model directory in "DCharts_TkinterFriendlyTest" has an example of how this works... no loss of functionality over the threaded version that I know of, and it is fast and stable! Yay.
  • -- May 25
  • Changed the default formalism for generating formalisms from Entity Relationship version 3 to Class Diagrams version 3. The addition of the inheritance mechanism should be of great use. Caveat: you can inherit attributes, but if you do, you can't use them as dynamaically displayed visual attributes. Also, graphical icons are not inherited.
  • Added Simon's fix for saving models with large numbers of connections.
  • Fixed a bug with regard to cardinalities when generating new formalisms. NOTE: do not use ER or CD original versions to create new formalisms, as they are still "broken".
  • Miscallaneous stuff: made the save/open dialogs a bit nicer, added a warning after generating formalisms that you need to reboot AToM3, and added an incomplete HTML help guide to AToM3.
  • -- May 17
  • Made a new logo for AToM3... modeled in AToM3 :D
    In the process, I identified 3 exceptional cases that caused Save/Load failure in a massively multi-formalism environment (I had 6 formalisms open at once!). They are now fixed!
  • I fixed the issue with the buttons graph grammar not generating buttons for Relationships. I think this was a *very* serious bug, and would affect all graph grammars had I not fixed it!
  • Ernesto didn't like my dynamically re-sizing buttons in the toolbar (on mouse over event), so I removed that behaviour... now they just turn red...
  • I fixed up the behaviour of the main Options Dialog when you change which Formalisms you want active and press Okay.
  • -- March 29
  • Implemented a secondary data structure to keep track of ASGroots (formalisms) ATTRIBUTES
    Apparently, just having a clear knowlege of which ASGroots were active was insufficient, I had to also make a copy of all the ASGroot attributes, and then figure out a way to LOAD them, MODIFY them, and SAVE them. Considerable amount of work in the juicy innards of AToM3 :p Hopefully, AToM3 is now completely multi-formalism! I know I'm able to modify buttons models at will even if I have X number of other meta-models open at the same time... so happiness :D
  • I added some methods in graphEntity.py that make Hierarchical connect/disconnect in a drag-n-drop situation very easy. IE: checks bounding box to see if other entities are under it, dialogs, etc.
  • Added a Help Document system to AToM3. Most notable is the one sported by the ERV3 formalism... a nice big question mark button! The system makes it *very* easy to add Help Documents to AToM3 inline. Indeed, I modified the button generating graph grammar to give you a new "HELP" button automatically. At the moment though, documents are still a bit sketchy, but the ways of using scripts in the Icon Editor, what exactly a Contraint/Action in the ER Model is, what all the colors & stipples in Tk are, are all explained in gory detail :D
  • Discovered a bug in the ERV3 button grammar, it doesn't generate buttons for relationships. I personally like it that way, so I'm having trouble building up motivation to fix it... Also, if you desperately want to drop an unsuable relationship on the canvas, you don't need a button, use the popup-menu and go to the 'Model' menu. You'll find it all there...
  • I juiced up the buttons model slightly... it now has a Help button, and an Edit button (so you can set formerly hard to find parameters!). Also, I've got buttons working very nicely, BUT *WARNING*, you must load buttons models with ONLY the buttons formalism active, for all buttons models created prior to this release of AToM3!!! This is stated in the Help file for buttons.
  • -- March 28
  • Implemented a secondary data structure to keep track of ASGroots (formalisms)
    The benefit: much better chances that if you save a model you'll be able to load it up again :D
  • Added try/except statements to save model code (specifically for generated ASGroot attributes). This is a very partial solution, but I can't seem to get my hands on the generated attributes before AToM3 squashes them into an unrecongizable pile of %$*@!.
  • It is now possible for an entity to lookup info in the ASGroot (ie: the model attributes you set through the M menu). This makes configuring parameters for all entities in a diagram very easy. If your interested in this, see ASG.py method getASGbyName(), or wait for me to release DevsV2 to see it in action...
  • Modified the Buttons model to warn users of the bad things that will happen if they start working on a Buttons model and another formalism is already open (Until I figure out the generated attributes problem, your going to have to walk on your tip toes on this one).
  • Fixed up the stipples for the indentation guide in the Text widgets
  • -- March 21
  • Fixed a few problems when saving models and then they don't want to load after.
  • Added the ability to easily specify a ERV3 relationship as being non-visual (ie: for insideness relations)
  • Miscallaneous other small changes... especially to graphEntity.py and graphLink.py (added stuff useful for layout, scaling, etc.)
  • -- March 20
  • Fixed yet another bug with the button creation grammar.
    This was a really really tough bug to track down. I'm surprised it wasn't revealed earlier... I guess that's because no one ever created new ER formalisms before though. Anyway, it's sooo handled.
  • -- March 19
    Sagar found a few bugs in AToM3... but no worries, I killed them :D
  • Fixed a bug involving the creation of new formalisms and editing visual icons, when the Transformation toolbar is open.
  • Fixed the Model menu system (Shortcut key is 'M'). Newly created formalisms will now have usable Model menu entries with which you can drop all entities in the formalisms, regardless of the fact that you might omit arrows from the buttons menu. (ie: This lets you use arrows for Graph Grammar transformations, even if no button is available). Currently supported by: EntityRelationV3 and Annotation
  • Fixed out of date Graph Grammar for creating buttons for new formalisms. The power of being able to edit the ERV3 Meta-Model must be tempered with caution :p
  • Fixed a bug when generating formalism buttons files (META file). The formalism file is now simply the name, with no path. Paths like: someDir\testing_MM.py were being interpreted as \t = tab, leading to bad things.
  • Improved the Graph Grammar transformation editor: now assumes 'Set to any' and 'Copy from LHS', since this is the most common case.
  • Changed edit entity --> Now shows the name of the entity being edited
  • Changed copy/paste attributes --> Now works between entities of any type, so long as they have some subset of attributes in common (ie: if they both have 'name' and nothing else in common, then only the 'name' attribute is copied). Also added a dialog box that shows you exactly what attributes have been copied. This feature is in the popup menu when hovering over an entity, or you can press Alt-C/Alt-V.
  • -- March 18
  • Fixed a bug where the text/code editing tool was causing exceptions because it couldn't find stipple files (xbm graphics). If it can't find them, you'll see a solid grey indentation guide instead of a nice dotted line. The horror.
  • -- March 17,2005
  • AToM3 now has its own IDE for Python coding. Everything you *need* is implemented. Most of what your *want* is implemented too
    I like it better than IDLE, although much of the code is taken from IDLE, but IDLE has no tab indentation guide!!! A must have!
    Also, you may wonder why the popup menu looks a tad wierd... that's because it's being automatically generated from the event-keybinds map (so keybinds & menus are always in sync). I find it kind of neat how the popup-menu is actually just generating the event the keypress would have generated
  • -- March 14,2005
  • Modified the AToM3 text widgets to support Python coding
    1) Syntax highlighting
    2) Tabs are spaces (but can still be deleted easily, as if they were tabs)
    3) Tabs are colored with a stipple line, makes indentation obvious
    4) # of spaces in a tab can be set easily (same button also re-calculates tab coloring)
    5) Todo: Add undo/redo and search/replace capabilities. Multi-line indent/unindent would be nice too
  • Discovered a bug whereby if you crash AToM3 alot, temp files build up, until WinXP refuses to make more! Therefore, from now on, whenever you exit AToM3 and choose 'Overide lock' for the options, ALL temporary files will be cleaned out, instead of just those associated with the current AToM3 process ID.
  • -- March 13, 2005
  • Modified Entity Relationship model: Entities and Relationships can now display exactly as much information as you want them to (example: you can make your entities visually abstract by displaying only the name, or you can make them very concrete by showing everything: Name, Attributes, Conditions, Actions, and Cardinalities). I expect AToM3 formalism makers to look carefully at what I have done here...
  • Added the ability to specify customized UI behavior model and keybindings code to make AToM3 work exactly as you like it
  • Added improved multi-formalism support, see options
  • Fixed Top Menubar option not working. The top menubar can now only be activated from the Options (since this works now!)
  • AToM3 logo in the top left now pops up the Options dialog (better use for the logo no?)
  • Graph grammar manual execution (where user must select where in the model the GG will operate), now uses the UI statechart
  • Added nice headers for automatically generated files
  • Fixed Icon Editor bugs with respect to editing arrow decorations
  • Added an arrow preview when designing arrow shapes
  • -- March 6, 2005
  • Fixed bug in the Graph Grammar execution code (was looping infinitely).
  • Added a new Entity Relationship formalism that fully boostraps itself, making its modification trivial.
  • -- March 3, 2005
  • I overhauled the Graph Grammar execution code. The 'Animate' option is now disabled until someone explains to me what it should be doing (crash in under 1 sec is probably not it...). All other combination of Graph Grammar execution option should now work better than ever. This means that if you have multiple rules of the same execution order, they will now be picked RANDOMLY! And if you use the Sequential-Manual mode, you can select the subgraph transformation target by simply left-clicking on it (I think the old AToM3 did this, but I have no idea how, so I re-implemented it).
  • BUG WARNING: I think there may be a bug hidden away somewhere. I was able to duplicate the bug without fail until I setup a barage of print statements (nothing else), and it completely disapeared...
  • BTW: The 'LetEntitiesMove' option seems to move each transformed entity by 100 pixels southeast. Is this what it is supposed to do? Is this useful?
  • Added 2 new editing methods, Edit Overlapping and Drag Overlapping which present a menu of all entities/links around the mouse cursor and let you choose one, and then either popup the edit dialog or initiate dragging mode. Previously, overlapping entities could be very difficult to select and operate on. You can find these new methods in the Right-Click popup menu when your mouse is over/near some object on the canvas. Or you could just press E for edit, D for drag.
  • Improved AToM3 initial installation setup (after watching the misadventures of fellow MSDL'ers). Also it has become apparent to me that the current AToM3 does not work with Python 2.2 nor with Python 2.3 on Win98 due to the fact that they treat import statements like "from LocalScript import SomceClass" as meaning LocalScript is in the directory where the first application boostrapping script is located. This would be simple to fix if I had either of these configurations available to me, but I no longer have Win98, and I can't get Tkinter to work on my Red Hat Linux 8. I'll find the neccessary setup sometime...
  • Bug that caused Graph Grammars to 'pretend to save' but actually not save, has been fixed after causing me untold agony.
  • AToM3 now strictly enforces naming conventions for:
    Models --> _MDL.py
    Meta-Models --> _META.py (Button model but it loads a formalism too)
    Graph Grammar Model --> _GG_mdl.py
    Executable Graph Grammar --> _GG_exec.py
    Graph Grammar Rule --> _GG_rule.py (Rules of the executable grammar)
  • Uncaught exception handlers have been added, they provide a GUI notification and log error to file, additionally, they assign each error a unique identification number to ease bug tracking. NOTE: This is applicable to any error that is passed to the standard Python exception handler, which I have overridden. If the error bypasses the exception handler and goes directly to STDERR, a GUI notice will still popup, but it will not generate a log entry at this time (since I believe this to be a very rare occurence).
  • Automatic generation of text and latex documentation from Graph Grammars is now supported
  • Graph Grammars are now supported (Do not use the Animate option when executing though...)
  • -- Sometime in 2005


    Coverability Graph via Automatic Layout (Summer 2004)

    I added an export function to AToM3 which allows it to export coverability graphs, such as those automatically generated for Petri-Nets, into some standardized graph langagues. The first is a human readable ascii descriptive language called GML (Graph Modeling Language). GraphViz and yED are two graph visualization tools that can read this format. The second is GXL (Graph Exchange Language), that can be imported by the open source JGraphpad tool. The third is DOT, which is recognized by the open source GraphViz visualization tool. See the links section for more information about these tools. The modifications to AToM3 are minimal, I merely extended an existing model specific menu to call my own python exporter file. A screenshot, for the curious, of what this looks like in AToM3 can be downloaded here.

    The most complex example of a coverability graph available to me at the moment is the one AToM3 automatically generates from a Petri Net model of a simple traffic system I made last year as part of a Modeling and Simulation course. It turns out that this coverability graph is extremely hard to represent well. The following algorithms were set loose on it:

    JGraphpad:

    GEM : Best JGraphpad algorithm, but node-node and edge-node overlaps are rampant, not to mention edge-edge crossings. Compactness is okay.
    Spring : Graph isn't compact enough, making it hard to read. Also suffers from node-node and edge-node overlap.
    Simulated Annealing : Extremely slow, the other algorithms were virtually real-time (on a 2700+ Athlon). I didn't stick around to see how long it took, but I estimate about 5-10 minutes to do the Petri-Net coverability graph. The results didn't warrant the running time at all either.
    Sugiyama : Applicable only to DAGs, and for some reason the DAG property got lost in the GXL translation. Note: this is a problem in the JGraphpad import mechanism, not inherent to the GXL language.

    GraphViz:

    Dot (Hierarchical) : Fairly nice, the spline curved edges in particular, but not the most compact representation.
    Neato (Force-Directed) : Too compact, everything overlapped.

    yED:

    Hierarchical : Not only reveals the underlying structure of the problem, but does in a near optimally compact fashion! Of course, this requires tweaking the settings a bit.
    Organic : Relatively compact graph, but edge-node crossings are rampant.
    Circular : Graph compactness is a major issue with this one.
    Orthogonal : Graph compactness is a problem, some edges in particular must be followed very far.

    The original model and coverability graph, along with the new automated hierarchical layouts can be viewed via the following links:

    Traffic Model Petri-Net
    Hand Done Coverability Graph
    Hierachical Coverability Graph
    Hierachical Coverability Graph (Abbreviated labels for greater compactness)
    Hierachical Coverability Graph (no intermediate nodes for edge labeling, uses a label placement post-processing step)
    Hierachical Coverability Graph (using the dot engine in GraphViz)

    Thus the hierarchical layout algorithm from yED appears to be the best suited for the task of laying out a coverability graph. Indeed, it looks considerably better than what I've done by hand. However, does it work as well for smaller graphs? To test this, I generated a coverability graph for the venerable producer-consumer model. The results show that the orthogonal layout algorithm has an edge in this case, as it is far more compact. Note: a label placing post processing step was applied in both these layouts.

    Hierachical coverability graph of a producer-consumer model
    Orthogonal coverability graph of a producer-consumer model

    Maintained by Denis Dube. Last Modified: 2008/09/09 18:03:05.