Demo Models

From Planimate Knowledge Base

Some of these models switch to "user mode" to create an end user environment. Ctrl-Shift-H toggles back to edit mode. For models that restart, Ctrl-T in edit mode will leave them stopped so they can be examined.

Contents 1 Example Models 2 Object Demos 2.1 PL5 Agent Objects Demo 2.2 PL5 Dispatcher Object Demo 2.3 PL5 Entry Object Demo 2.4 PL5 Exit Object Demo 2.5 PL5 MultiServer Object Demo 2.6 PL5 Pipe Object Demo 2.7 PL5 Portal Object Demo 2.8 PL5 Queue Object Demo 2.9 PL5 Spatial Link Object Demo 2.10 PL5 Splitter Object Demo 2.11 PL5 Switch Object Demo 3 PL5 Training 4 Techniques 4.1 Advanced 4.1.1 BATCH/BatchTest 4.1.2 Broadcasts and Zero TIme 4.1.3 Clock Based Conditions 4.1.4 Dynamic Table Reference 4.1.5 Dynamic Viewport 4.1.6 Event Threads, Zero Time and Event Order 4.1.7 InSwitch Unblocking 4.1.8 Object Create Delete 4.1.9 Portals Multiple Entries Exits 4.1.10 Read Carried Item Attributes 4.1.11 Recursion Using Subroutines 4.1.12 References 4.1.13 Remapper Table 4.1.14 socket_client and socket_server 4.1.15 Synchronised Random Streams 4.1.16 System Generated Broadcasts 4.1.17 Table Column Insert Delete 4.1.18 Table Options 4.1.19 Time Operations 4.1.20 Wormholes 4.2 Data 4.2.1 Attribute Views 4.2.2 DataSet/DataSet2 4.2.3 FileAccess/FileOperations 4.2.4 FileAccess/File Lock 4.2.5 Gantt Table View 4.2.6 Graphing Demo 4.2.7 Linear Regression 4.2.8 OS Formats 4.2.9 PDF 4.3 Fundamentals 4.3.1 Attribute Routing 4.3.2 Event Generation 4.3.3 Icon Assignment 4.3.4 Item Carrying Item 4.3.5 Loops 4.3.6 Message Dispatcher 4.3.7 Messages and Broadcasts 4.3.8 Messages and Carried Items 4.3.9 Multiple Runs 4.3.10 Portal Attributes 4.3.11 Portal States 4.3.12 Release Dispatcher 4.3.13 Routines Case If Dialog 4.4 Graphics 4.4.1 Animation Tests 4.4.1.1 01 Single Multiframe Icon 4.4.1.2 02 Single Animate Fast (5000 items) 4.4.1.3 03 Portal State Change 4.4.1.4 04 Animate Over Time (small) 4.4.1.5 05 Animate Over Time 4.4.1.6 06 Animate Over Time With Portals 4.4.1.7 07 Rotation And Animation Over Time 4.4.1.8 08 Animation Crossover 4.4.1.9 09 Animation And Sync Change Portals 4.4.1.10 10 Rotation Animation Crossover 4.4.1.11 11 Item Info Panel Plus Multiframe 4.4.1.12 12 Transparent Info Panels 4.4.1.13 13 Info Panels Over Synced Portals 4.4.1.14 14 Animation Over Random Portal States 4.4.1.15 15 Pipe 4.4.1.16 16 Bouncy Portals 4.4.1.17 17 Bouncy Portals and Links 4.4.1.18 18 Log Driven Graph Animate 4.4.2 Any Orientation Dispatcher 4.4.3 Chasey - Multiple Moving Portals 4.4.4 Life - Table Grid View 4.4.5 Moving Portal 4.4.6 RGB - Table Grid View 4.4.7 Save BMP Image 4.5 Networks 4.5.1 Pipe 4.5.1.1 Pipe 2 Way 4.5.1.2 Pipe - Multiple 4.5.1.3 Pipe - Single 4.5.1.4 Pipe Table 4.5.1.5 Pipe Limit Broadcast 4.5.2 Spatial Link 4.5.2.1 Dynamic Spatial Networks 4.5.2.2 Spatial Link Item Throw 4.5.2.3 Spatial Link Viewed As Pipe 4.5.2.4 Spatial Link 4.5.3 Dynamic Bend Points 4.5.4 Dynamic Positioning Objects 4.6 UI 4.6.1 Anchor Demo 4.6.2 Dial Image by Label List 4.6.3 Dials 4.6.4 Paint Button With States 4.6.5 Paint Hover Broadcast 4.6.6 Panel Popup Palette 4.6.7 PopUpMenu and Menubar Set 4.6.8 Portal Clicked And Moved 4.6.9 Set Viewport Scroll 4.6.10 Table Cell Click PopUp 4.6.11 Table Colours 4.6.12 Table Configured Log Driven Graph 4.6.13 User Editable Table Mapper Graph

Example Models

Object Demos

PL5 Agent Objects Demo

Demonstrates items carrying other items (called agents) and the associated PickUp and DropOff objects.

PL5 Dispatcher Object Demo

Demonstrates Dispatcher objects which unlike a Queue do not enforce an exit order for items. Dispatchers are often used for messaging and broadcasting to other parts of a model as they provide somewhere for the original item to wait.

PL5 Entry Object Demo

Demonstrates Entry objects which not only introduce items into a model but also act as receiver points for broadcasts and messages from other parts of a model.

PL5 Exit Object Demo

Demonstrates Exit objects. As well as disposing of items, exits can return messages to their sender and trigger other actions (like broadcasts or stopping the run).

PL5 MultiServer Object Demo

Demonstrates MultiServer objects which are used to simulate delays. MultiServers can be configured to delay multiple items (hence the "multi") with times based on constants, attributes or with random variation. MultiServers can display as icons or as a timeline or "road", the latter which can be used to achieve a simple spatial network animation without using Spatial Links or Tracks.

PL5 Pipe Object Demo

Demonstrates Pipe objects which can be used to simulate and animate the flow of material (represented numerically) from one location to another.

PL5 Portal Object Demo

Demonstrates Portal objects which enable complex models to be split into a hierarchy and are easily copied, duplicated and even replaced in a model. Portals play important roles in Network Models.

PL5 Queue Object Demo

Demonstrates Queue objects which provide a place for items to wait while a resource ahead of them is busy or occupied.

PL5 Spatial Link Object Demo

Demonstrates Spatial Link objects which are used to create spatial network models where objects move between nodes in a network over links which take time to traverse (unlike flows which are instantaneous from the model's point of view). This is useful in modelling long haul transportation networks.

Also demonstrates how a spatial link can have pipe-like animation associated with it. This can be useful where pipe animation is desired without the complexity of managing numerical values that flow between attributes.

PL5 Splitter Object Demo

Demonstrates Splitter objects. These take one item and immediately produce multiple items, optionally cloning the icon and attributes of the original item.

Splitters are used where a number of separate but related actions need to occur as the result of one event in situations where the actions are relatively local. In other cases, a broadcast can be used to trigger many actions from one event.

PL5 Switch Object Demo

Demonstrates Switch objects, which enable decisions to be made in Planimate's graphical flow representation of logic. It demonstrates the distinction between item routing items (where non blocking switches are often used) and blocking (where blocking switches are used).

A unique characteristic of Planimate's Switches is that they can test and make a decision for an item before the item has even moved to the switch! This is called lookahead and enables very powerful decision making rules to be modelled graphically.

PL5 Training

Techniques

Advanced

BATCH/BatchTest

Demonstrates running Planimate in batch mode and using an INI File to pass some parameters to the model. The model is a simple server/queue (with variation) where portal attributes 'arrival_interval' and 'delay' as inputs. It runs for a period and then writes results to a file "report.txt". The batch file creates a Model INI file with input parameters to the model, runs Planimate to run the model and then displays the resulting log file. This is done twice with different parameters.

Broadcasts and Zero TIme

This model sends broadcasts using various mechanisms. It shows how events at the same time ("zero time") are always processed when a broadcast is sent, whereas events after a delay require that the engine "continues" the run in order for them to be processed.

Clock Based Conditions

This demonstrates how the simulation clock can be used to control where items are routed by a switch but cannot be used in switches to block an item. The correct approach is to use a multiserver delay to hold the item for the desired delay.

Dynamic Table Reference

This demonstrates the use of dynamic table references in routines, enabling a table reference to use the name of a table which is determined at runtime. Note that item table references (where an item can "point" to a table) may offer a better alternative in cases where one of a number of tables need to be selected.

Dynamic Viewport

Demonstrates how the "target" that a viewport displays can be changed on the fly by the model. Hovering above each portal displays inside it. Each portal has a hover-handler that sets the viewport to point to itself.

Event Threads, Zero Time and Event Order

This contains a number of subsystems each demonstrating concepts relating to how events are processed in Planimate.

This includes: - not relying on the order of events triggered at the same time (like broadcasts) - messaging and broadcasting - what happens when - attribute controlled gates, making sure the gate is shut behind you - graphical loops (as compared to iterating inside a routine)

InSwitch Unblocking

Demonstrates the different ways that an object can choose which item enters it next when there are more than one objects with items waiting behind it.

Object Create Delete

Demonstrates how portals in a model can be created under model control. Edit the table (eg: change command to delete) to see the effect when the button is pressed.

Portals Multiple Entries Exits

Demonstrates the use of multiple entries and exits inside a subsystem and how they can be used by the owning portal to keep items of the same class on separate flows.

Read Carried Item Attributes

Demonstrates how item attributes of an item being carried can be referenced. In this model you click to create an item, it gets assigned a random destination and then picked up by another item, the "agent". The carried item is then inspected and delivered to the desired location and dropped off. The agent then returns and waits for another item.

Recursion Using Subroutines

Demonstrates how subroutines can call themselves recursively. The change object contains a routine that calls itself to find a value from the fibonacci sequence.

References

This is not a runnable model but rather illustrates the different ways data can be referrrrrenced in a model, including constants, portal attributes, item attributes and table cell references.

Remapper Table

Demonstrates how a table with the "Act As Mapper" table option turned on will display the first column as the x-axis in a table view, plus enable references to translate or remap data directly without needing any calculations to be performed in code. This is useful for specifying profiles and complex behaviours.

socket_client and socket_server

Together these demonstrate how two instances of Planimate can communicate via TCP/IP. Items created in one model appear in the other model as well.

Load both models in separate instances of Planimate and run them. Initially use the click entries on the client model to create items. These will appear in both models. once connected, you can also create items in the server model and they will appear in the client model.

The models are set up to run on the same PC but you can configure the client to connect to another PC by editing Settings -> TCP/IP Sockets and setting the IP address of the server instead of the default 127.0.0.1. You will also need to allow connections to Planimate on the server PC's software firewall.

Synchronised Random Streams

Demonstrates how two random sources can be synchronised by having them use different random generator streams which are initialised with the same random number stream, causing them to behave identically.

System Generated Broadcasts

Demonstrates broadcasts sent by the Planimate engine as it starts, continues and stops a model run.

A modeller can add handler code in this broadcasts to initialise data, prepare the UI and even prompt the user to save data when the model is about to be closed. This assists in making models feel more like applications to the user.

Table Column Insert Delete

Demonstrates inserting, deleting and copying columns between tables at runtime using routine code.

Table Options

Demonstrates a few of the many table / table view options which are not on by default. This includes:

• use of table view graphics properties to customise title, alternate row colours and hover colours
• value, monetary and date formatted columns
• hover tracking view option
• single click to edit view option
• Label selection by dialog, combo list and dynamically filtered combo lists
• text typed in-place (no label list needed)
• column filters (use to filter which rows are displayed)
• context click capture (suppressing the default menu)
• column tool tips
• resizeable columns (drag in the column title dividers)
• user sort (click title of the table in "user mode" (ctrl-shift-H)
• cell edit, scroll and sort broadcasts (click on items captured to inspect cell click broadcast information). Note that broadcasts on cell edits are sent after edit in this model, though sending a broadcast before edit is an option as well.

Time Operations

Demonstrates time/date decoding routine operations by generating a random date and then using a few routine operations and showing the results in attribute views.

Wormholes

Demonstrates wormhole entries and exits. These enable an item to jump from one location in a model to another without having to flow over intermediate objects.

Data

Attribute Views

Demonstrates the different ways that attribute views behave, which is determined by the type of data their attribute is formatted for (value, time, date, label, text) and the options selected for the attribute view. Note that table columns have similar options to attribute views, the behaviour applies to the entire column.

DataSet/DataSet2

Demonstrates saving and loading Planimate dataset2 files, including the ability to save table data, labels and include external files into a dataset2 file. Start by saving a dataset2 then manually clear out the lower table and rename CONTSHIP.BMP to a different file. When you reload the dataset2 file, the table will be recreated and the file will be extracted. You can also test rearranging the columns in the lower table before loading, noting how the dataset2 mechanism will find and match the columns even if some have been deleted or new ones added.

FileAccess/FileOperations

Demonstrates writing data files in tab delimited and comma separated format and reading data back into a table. It also shows invoking an external program (notepad in this case), reading file size and file lines and also how to dynamically specify file names using attributes and text expressions.

FileAccess/File Lock

Demonstrates Planimate's AcquireFileLock/ReleaseFileLock change object file operations. These simplify managing cases where multiple instances of Planimate (running on the same computer or different workstations with a shared network drive) share access to common data files and locking of access to one instance needs to be enforced.

The model demonstrates the ability to include text in the lock (to assist in idenfifying who created it).

Load the model in two instances of Planimate. Once one has acauired the lock, the other one will be unable to acquire it until the first one releases the lock (or is closed).

Gantt Table View

Demonstrates table data driving a Gantt Table View object. A simple routine generates random events

Graphing Demo

Contains simple examples of Column Overlay, Log Driven, Train Graph and Gantt Graphs and quite a few explanatory notes.

Linear Regression

Demonstrates a simple tool where x/y data is input to a table. Clicking the "Compute Regression Line" runs a routine (in the Routines portal) which performs a linear regression on the data, resulting in the formula to a line. A value can then be entered in the TEST_X attribute view and the Update button used to calculate the corresponding Y value using the derived regression line.

OS Formats

Demonstrates Planimate using formatting defined in the Operating System's Regional Settings control Panel.

The upper table view is raw data, minimally formatted. The lower table view is a customised table view of the same data, formatted using the "OS Value", "Os Currency", "OS Time", "OS Date" and "OS DateTime" formatting modes. The way the lower table is presented will depend on the regional settings which can affect how dates are shown, usage of decimal commas and the monetary symbol. This can be useful for applications intended to run in international markets.

PDF

Demonstrates use of the Normalise and Convolve routine operations to combine two Probability Density Functions (PDFs) which are graphically specified.

The two graphs on the left can be interactively edited by dragging the points up and down. The routine takes care of ensuring the data is normalised (area under curve is one), sets up the scales of the input and output data and uses the Convolve operation. This can be useful in modelling complex systems where multiple random effects need to be combined. The graphical input is useful where a user wants to test how the "shape" of the variation affects the outcome.

Fundamentals

Attribute Routing

Demonstrates how a random number can be generated in a routine, stored in an item attribute then used in a switch to route the item.

The model is more complex than first looks because the switch has been configured to allow blocking back to the queue behind it. To achieve this, it needs to know the item's "choice" before the item actually leaves the queue! Planimate achieves this using its "lookahead" capability.

The queue is important because it prevents interference between the Change and the Entry. Both are drawing from the same random generator before the item actually moves to the Change object which sets its route. (The Entry draws a random number to determine the next item's departure time).

Lookahead can be used to model very complex decision making, especially in networks. Its an important fundamental concept which distinguishes Planimate from regular programming languages.

Event Generation

Demonstrates the numerous ways that events (typically Items) are produced in a model. The buttons at the top (paint objects) show a number of panels with examples.

The examples include:

• Mathematically distributed events
• Clickable entry events (useful for debugging)
• Messages and Broadcasts (useful for communication within a model)
• Modeller created "event engine" using a splitter and cycling item
• Table Driven events (useful in running pre-determined schedules)
• User interface triggered events (button clicks etc through broadcasts)
• Sensor Entries (attribute value changes)
• Planimate generated events. Many of Planimate's views and internal mechanisms can be configured to generate broadcasts that the modeller can listen out for.

Icon Assignment

This demonstrates how icons can be assigned to an item "on the fly".

An attribute value can be used as an index by which an icon is assigned to the item, enabling items of the same class to have different iconic representations - perhaps to reflect different state the items are in or other differences you may wish to highlight.

One advantage of this method is that the number of item classes in your model can be reduced - which means less flow editing of different but similar classes, whilst retaining the ability to produce a pictorial differentiation between items.

Once you start using attributes to distinguish items instead of class, you will also need to manage logging and analysis based on these attributes.

Item Carrying Item

Demonstrates how tne PickUp and DropOff objects can be used to cause an item to "carry" other items around with it. An important requirement is distinguishing who is the carrier and who is to be carried. This can be set as a default property of an item class and also, as this model shows, set on-the-fly on an individual item basis.

Carrier items are called "Agents". The process can be nested - a carrier can become an item carried by yet another carrier. This can be useful in manufacturing and logistics models where it is useful to have sub-components carried through the network.

Whilst the same end can be achieved by using tables to track what each item is "carrying", having an "actual" set of items, which can be dropped off, interrogated and then picked up again makes the process much more visible.

Loops

Demonstrates the use of loops. A ITERATEROWS loop is used to fill a table with random values. A WHILE loop is then used to iterate through the same table to analyse the values generated. A Table View, Dial and Label formatted attribute are used to present dynamically updating results to the user numerically, graphically and textually.

Message Dispatcher

Demonstrates how a Dispatcher can be used to send a "message" to another location in the model. A message has a single receiver and the original item waits in the dispatcher until the message item completes its journey and enters an exit.

Attributes and properties of the original item are transferred to the message item. When the message item reaches an exit, changes made to it are transferred back to the original item which then can leave the dispatcher.

Note that the dispatcher is not FIFO like a queue, items can leave in any order.

Messages and Broadcasts

Use the menu on the left to select a number of panels. These demonstrate basic concepts in broadcasting and sending messages, including

• Scoped vs global broadcasts, with the hierarchy displayed on one panel using viewports
• Sending messages to a destination specified at runtime
• Waiting for a broadcast to complete vs. not waiting.

There are extensive notes in the model which explain the different situations.

Messages and Carried Items

Demonstrates that Messages and Item Carrying can be used together. When a message is sent, the message item will be carrying all the items the originating item was carrying. It will return all items it subsequently is carrying when the message item exits.

Multiple Runs

Demonstrates multiple runs using a simple model. Using the Run menu's Multiple Run dialog, you can specify a number of runs and they will be performed.

This model uses Planimate's inbuilt logging capabilites to write LOG files which the Log Viewer application can display graphically. More sophisticated models collect data internally and display it using the graphical table views.

Portal Attributes

Demonstrates how portals can have attributes private to them (scoped) and how such a portal can then be copied and have its values customised. It also makes use of attribute views which display, move and copy along with the portal's icon. Copy and paste one of the portals to try this.

Portal States

Demonstrates how a portal can be configured with an arbitrary number of states, each given a different icon and then have its state set dynamically by the model. It also uses routine code to generate random numbers (which determine the state) and collect statistics into a table which is then graphically displayed using two column overlay views.

Release Dispatcher

Demonstrates a dispatcher mode in which items wait in the dispatcher until a routine operation specifically requests release of an item by its item-id. This can be useful in complex wait-until situations and avoid using a blocking attribute switc with many items behind it, which is not as efficient.

Routines Case If Dialog

Demonstrates routine basics including IF statements and SELECT/CASE. A dialog triggered by the routine appears and the response made in the dialog is used to direct the code.

Also uses a Dial for activity display and a table and column overlay view to show the distribution of randomly chosen numbers.

Graphics

Animation Tests

This folder contains models which test the performance of Planimate's animation manager. They demonstrate some advanced graphical capabilities.

01 Single Multiframe Icon

Demonstrates how an object or item icon can consist of multiple images which are animated as the item moves or over time as the item waits in one location, like a queue. Its similar to an "animated GIF" except the images are not packed into one file but rather combined based on their naming.

02 Single Animate Fast (5000 items)

Sends 5000 items through a simple model with the maximum animation speed. Note that models run much faster when "advancing to time" as there are no animation overheads at all.

03 Portal State Change

A small group of portals change their icons together, preserving the background behind them.

04 Animate Over Time (small)

A small group of items move together over a multiserver configured to display as a road. This is not "zero time" flow animation of a single event but rather animation over simulated time.

05 Animate Over Time

A larger group of items move together over a multiserver-road. This tests performance with more simultaneously moving items.

06 Animate Over Time With Portals

A number of items move together over a road. There are many portals with unchanging icons which the items cross over. This tests performance in typical conditions of a complex spatial network display.

07 Rotation And Animation Over Time

This demonstrates multi-frame items and portals which appear to rotate. The items move smoothly over the rotating portals.

08 Animation Crossover

Two large groups of items cross paths whilst moving over separate roads, without leaving debris or slowing down whilst intersecting.

09 Animation And Sync Change Portals

Many items animate over a field of 500 portals which are all changing state simultaneously. The large number of changing portals have little impact in the smoothness of the movement of the animating items.

10 Rotation Animation Crossover

Many auto-rotated items animate along with some multi-frame 'spinning" items, in two large groups which intersect with each other. This tests the manager's ability to handle more complexity.

11 Item Info Panel Plus Multiframe

A multi-frame item with a textured info panel animates through a trivial model.

12 Transparent Info Panels

A number of items with transparent info panels move on a road.

13 Info Panels Over Synced Portals

Many items with info panels move over a road and over a large group of portals changing state together. This tests how much the portals impact item movement even when the animation is under load from the many info panels.

14 Animation Over Random Portal States

Tests that animations on multiple panels viewed at the same time (using a viewport) do not impact on each other, as well as the portals not impacting on the animation of the items.

15 Pipe

Animates a few pipes, used to test basic animation / load.

16 Bouncy Portals

Demonstrates how a large number of portal objects can be simultaneously animated in a smooth and fast manner.

17 Bouncy Portals and Links

Tests animation of a number of moving portals with some having spatial links connecting them.

18 Log Driven Graph Animate

Demonstrates how a graph can be animated over time, including gradually changing colours, positions and data point sizes.

Any Orientation Dispatcher

Demonstrates Dispatchers with their direction set to "Any Orientation". This enables them to be oriented in any direction (by positioning their exit) and will queue icons of different sizes neatly without overlap or large gaps. It works best with item classes with both the "Auto Rotate" and "Flip Icons" item class options turned on.

Chasey - Multiple Moving Portals

Demonstrates portals which animate themselves. A swarm of portals chases the mouse cursor. The Start button randomises them. Press Stop to pause and change the parameters. A bit of random variation is included in the portal positioning to keep things interesting.

This is a good model to learn about Ctrl-Paste replacing. With the run stopped and using the   sidebar hierarchy browser, you can easily locate and edit one portal, eg: "!p1" by clicking on it. You can quickly replicate a change to all the other portals by copying the portal (right-click portal in the sidebar and select copy). Then select the <main> panel, right click on the background and then hold Ctrl while selecting "Paste Portal" from the background menu. For this model, you can just enter "*" into the Recursive Replace Match Name dialog and all the portals will be updated.

Life - Table Grid View

Demonstrates the use of a Table Grid View to display the contents of a table as a graphical grid that can respond to clicks. This is used to implement John Conway's Game Of Life. Whilst paused you can click on cells to turn them on and off. Stop the run and type Ctrl-Shift-H to switch to edit mode. The "Life" change object inside the "Processing" portal implements the rules of the game.

Moving Portal

Demonstrates a portal which can position itself based on which of 4 entries are clicked. The portal is implemented using multiple portal entries, each associated with a different flow entering the portal. This enables it to respond differently to the different entries, even though they all send the same item class into the portal.

RGB - Table Grid View

Demonstrates the grid view in RGB colour display mode (as distinct to icon display mode used in the Life model). In this mode every cell of a table is interpreted as an RGB colour, enabling graphics like heat maps to be displayed by the model. In this case a formula creates a pretty animation.

Save BMP Image

Demonstrates the use of a Change Object - File operation, in this case saving a panel's display to a BMP file. The first change object saves the current panel. The second change object has an object label for a portal as a Data Target. This will cause it to save the subsystem of that portal instead.

Networks

Pipe

Pipe 2 Way

A simple pipe model where material transferred by one pipe (at 100 units/hour) is split to two pipes with a 60/40 split. The pipe properties are set by right clicking on them in edit mode. Right clicking a pipe in run pause mode shows its operational status.

Once there is no more material at Portal 1, pause and "reverse" the direction using the direction control view then continue the run. This illustrates how the direction of transfer can be changed using the pipe's control attribute.

Pipe - Multiple

Demonstrates creating feedback loops with pipes and different pipe animation colours and spacings.

The source and destination bins are dial views of a hidden attribute. Clicking on the bins enables you to set its level graphically.

Pipe - Single

Demonstrates a single pipe (with a bend point) transferring quantity from one attribute to another. Dial views display the attributes at the ends of the pipe. The attributes auto-reset to their default "clear" value each time the run is started.

Pipe Table

Demonstrates an advanved mode of pipe operation where an entire row of data is transferred between the end points of the pipe.

The pipe is pointed at a specific column on each end, the primary column. It will then transfer the data in other columns in proportion to the amount it transfers from the primary column.

In this mode there is no "pipe delay", the transfer is instantaneous between endpoints but sampling still occurs.

Pipe Limit Broadcast

Demonstrates advanced pipe options "Source/Target Limit" and "Broadcast Limit Events". With these selected, Planimate sends a system broadcast "_Pipe Event" when the source or target cross preset limits (which may be attributes). The broadcast can notify can take actions like stopping the pipe or starting other processes.

In this example the pipe is stopped by the broadcast when its destination reaches 5000 units.

Spatial Link

Dynamic Spatial Networks

Demonstrates how a spatial network can be constructed on-the-fly between existing nodes/portals.

The objective is to add links to connect portal 1 to portal 6. A test item can then be sent through the network and it will automatically determine a route from portal 1 to portal 6.

The model implements a simple editor for adding links between portals. This editor also tests for existing links and any attempts to link to "self". A 6x6 table is used to maintain the status of links between nodes. Note that the links in this model can be traversed in either direction.

Spatial Link Item Throw

Demonstrates spatial network management basics. "From" and "To" attribute views enable a pair of locations in a simple spatial network to be specified. Pressing the "Produce One" button puts an item onto the network, which traverses between the selected locations.

The button sends a broadcast which is handled inside the Handlers subsystem. The "prepare" routine sets the destination for the item (s.ItemTransitTarget) and the total travel time (s.ItemTransitTime). The item is now ready to traverse the spatial network but it has to be placed at the origin. This is achieved by "throwing" the item using an exit in "Place Item Into Object" mode.

Whilst the destination for the throw could be a queue, in this model it is a portal - the starting location for the item. To deal with thrown items, a portal looks for a queue called "_!catch" and places the item therein. The item then proceeds inside the portal, just as if it was created by an entry in the portal.

The model contains a table that logs the number of items dispatched to a given origin/destination pair. The structure of this table depends on the number of locations in the network. To make adding new locations easier, the model contains a routine that completely rebuilds the table from scratch, creating columns, rows, setting titles and formatting.

Spatial Link Viewed As Pipe

Demonstrates a spatial link with the "Pipe Display Mode" option selected. In this mode, the spatial link is displayed as if it was a pipe and items flowing through it can change the colour-state of segments along the spatial link, giving the appearance of material flowing through the pipe.

Unlike a regular pipe, no attribute values are involved, the pipe states are set by items undergoing what is otherwise a single spatial link delay along the length of the spatial link segment.

Spatial Link

A model with a number of spatial links (bent with bend points) on which many items move between locations, on different routes and at different speeds.

Dynamic Bend Points

Demonstrates how all bend points on spatial links can be read into a table and restored. This is useful with dynamically generated networks and in retaining user-added bend points when a network is regenerated.

The table is preloaded with some bend points so click the "Set" entry first otherwise they will be lost. You can then stop the model and move/add/delete bend points then run and click the "Get" entry to retrieve their co-ordinates.

This same technique also works with pipes and tracks.

Dynamic Positioning Objects

Demonstrates how objects can be repositioned during a model run. In this case there are 2 alternate co-ordinate sets for objects in a network, one geographically based and the other schematically based (typically used in a train network display).

Click the display button then use the "Position Geographically" and "Position Schematically" buttons to reconfigure the network. You can do this after starting the run whilst items are on the links, after pausing the run.

The geographic view can be zoomed by setting the range of latitude/longitude co-ordinates. This is useful in large, complex networks and can avoid having to manage incredibly large panels (maps on a continental scale).

The "Locn Management" portal on the main panel contains the code which positions the location objects. It also contains a click entry which will read the current position of the objects and place it into the schematic table.

UI

Anchor Demo

Demonstrates the use of anchors on views and paint objects to create resizeable panels. Click the button and try resizing the Planimate application window. The model needs to be running for the panel to update properly. Anchoring in Planimate is very simplistic and is augmented by some code in Portal 2 which is triggered by a resize broadcast.

Dial Image by Label List

Demonstrates a Dial configured to display a different image based on a value and a label list which translates the value to the name of the image to use.

Note that a multiple-state paint button can also display different images based on an attribute value.

Dials

Demonstrates dial displays of data, including sliders and strip charts. Dials offer a quick, interactive graphical display not requiring any broadcasts or tables.

Dials are an option on attribute views. To reduce clutter, views of the same attribute have been hidden, leaving just their associated dial. The hidden views are available in the Panel -> Views menubar option.

Paint Button With States

This demonstrates the ability for paint buttons to have multiple states with different graphical display and how the modeller can read and set those states.

Paint Hover Broadcast

Demonstrates a paint button configured to respond to the mouse hovering over it. If the model is running, it also sends a notification broadcast when its state changes.

Panel Popup Palette

Demonstrates popping up another panel in a separate window. Run and click the top entry to show the panel. Closing the panel sends a broadcast back to the model so it knows the user has finished with it. The panel's window style can be set using the option. Right click the _panel label in the tree view, select "Subsystem->Panel Options" then select "Popup" in the options editor.

PopUpMenu and Menubar Set

Demonstrates creating hierarchical popup menus and menu bars using a table to define the text, structure and command code that the menu items will have.

Portal Clicked And Moved

Demonstrates a portal configured to be draggable and clickable during the model run. Broadcasts are sent to the model for these actions, enabling it to track the changes and respond. This is useful in network models where the user can make configuration changes.

Set Viewport Scroll

Demonstrates setting the scroll of a viewport in code. This can be used to point a viewport at different parts of its subsystem, depending on what the user is interested in looking at.

Table Cell Click PopUp

Demonstrates cell click broadcasts and opening a popup panel with details of the click. Typically this could retrieve further information about the data in the cell that was clicked. The table view is configured to send the broadcast without the default cell editing.

Table Colours

Demonstrates a table configured to use its own columns to set the row text and background colours. Two views of the table are on the panel, one is customised to remove the two colour configuration columns. This is normally what an end user would see.

The attributes and click-entries below the table views demonstrate how colours can be overridden on a cell by cell basis. This can be useful in highlighting edited data or items of interest.

Table Configured Log Driven Graph

Demonstrates a Log Driven Graph where configurations for the various overlays are provided by a separate table, minimising the columns needed in the data log which drives the graph.

User Editable Table Mapper Graph

Demonstrates the use of a Column Overlay View together with the table options"Act As Mapper" and "User Cannot Add Rows" to implement a quick editor for graphical profiles such as distributions.