Search the Community

Hi, I want to create a component with N entry nodes and with M exit nodes, where N may be equal to M. What is the easiest way to achieve that in Simio? Thanks!

We have expanded our API with Simio Version 5....Now we have the ability to add links to networks. This should drastically reduce the time needed to create a network. We also have the ability to modify the size of object through the API. The new files for version 5 are attached to this post. NOTE: If you are downloading just the assembly, there are couple of extra steps: 1) Extract "ImportObjectsAndLinksFromSpreadsheetAddIn.dll" from the "ImportObjectsAndLinksFromSpreadsheetDLL_V5.zip" into a temp folder (e.g. c:\temp). 2) Right-click the assembly and select properties. Then choose to "unblock" button and press apply. (only needed for Windows 7 and later). 3) Copy the assembly into "C:\Users\\Documents\SimioUserExtensions" 2016-01-27...Remove attachments...Use attachments in Alan Sagan's post.

The Extended Flow Library discussed in this thread is now obsolete. Most of its objects are now integrated into the Simio Flow Library or included in the new Candidate Library: http://www.simio.com/forums/viewtopic.php?f=36&t=1740 The built-in Flow library includes very powerful features and capability, but is currently limited in scope to just a few basic objects. While we are enhancing that built-in library based on your feedback, we have provided an extended set of flow-related objects. This library includes objects such as Solidifier, Liquefier, Filler, Extractor and Stockpile. A Solidifier can be used to convert a specified quantity of flow into discrete entities. A Liquefier converts a discrete entity into an outbound flow. The Filler is similar to a Combiner that combines input flow of a specified volume with a discrete entity and the combined entity departs the Filler. The Extractor is the flow equivalent of the Separator. It will separate a batch member entity from the parent entity, with the flow transfer of the batch member entity then discrete transfer of the parent entity once flow is complete. The Stockpile object is similar to a Tank with different animation graphics. ExtendedFlowLibrary.zip As we receive customer feedback on both the Flow Library and the Extended Flow Library we will probably build more of this type of capability directly into the Flow Library. But in the interim, hopefully this extended library will help in your modeling. Like all Simio-provided libraries, this library is open so you can look at how it was built, learn from it, and subclass your own objects to improve them. But unlike our built-in libraries, this is not fully supported (although we can provide some help) and we may not continue enhancing it, particularly if we decide to build this capability into the base Simio products. We are anxious to receive your feedback on this library.

I've created a tool which makes my life a bit easier when trying to code Design Add-Ins for Simio and I thought that I would share it with everyone else. Disclaimer: I'm an engineer that is mostly self-taught when it comes to programming so it may not work (all I know is that it works on my pc ). Also I know that it isn't the prettiest piece of software either. What the tool does is allow you to try c# code directly within Simio and evaluate the results. If you have ever used a dynamic programming language like Matlab or Mathematica then it will be familiar to you. Its like the command window in Matlab where you can enter commands without compiling. Its called a REPL (Read-Eval-Print-Loop). more info here: http://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop The code uses the Microsoft Roslyn Compiler API. more info here: http://en.wikipedia.org/wiki/Microsoft_Roslyn If you want to play around with the source code then you will probably need to install the Roslyn CTP. Download here: http://msdn.microsoft.com/en-gb/roslyn. I created the solution using Visual Studio 2012 and I believe that the roslyn compiler only works with VS 2012 at the moment. How to install: 1) Copy the SimioREPL folder from the zip file into either: C:\Program Files\Simio\UserExtensions or c:\Program Files (x86)\Simio\UserExtensions 2) The folder structure should be ..\Simio\UserExtensions\SimioREPL How to get started: 1) Create a new model in simio. 2) Select SimioREPL from the Select Add-In drop Menu (Project Home Ribbon) 3) Click "Insert Initializing Code" button. This inserts some code to get the whole thing going. You may need to change the directory of the dlls loaded if you are not using a 64-bit machine (delete the x86 part from the path). 4) Press the Execute button to evaluate the code. 5) You can now start playing with the interactive coding environment The bottom textbox displays the results from each execution loop. If no return values are given then it will display just the execution count. How to use (here is an example of how to use the tool): Enter c# code just like in a normal program, for example: int x = 10; You can find out the current value of a variable by entering its name without the ending semi-colon, for example: x or x*2 + 10 -3 This will display the value in the output text box at the bottom of the window. I've added the ability to use Write() and WriteLine(), just like in a console application. for example: WriteLine(object.ObjectName); If the code is invalid then the Exception message will be displayed in the results text box, and the input code will remain. If the code is valid then the input code is cleared. The context object is already defined. Use context as you normally would. Some example code Walkthrough: Add some objects to the model IIntelligentObjects intelligentObjects = context.ActiveModel.Facility.IntelligentObjects; IFixedObject sourceObject = intelligentObjects.CreateObject("Source", new FacilityLocation(-5, 0, -5)) as IFixedObject; IFixedObject serverObject = intelligentObjects.CreateObject("Server", new FacilityLocation(0, 0, 0)) as IFixedObject; IFixedObject sinkObject = intelligentObjects.CreateObject("Sink", new FacilityLocation(5, 0, 5)) as IFixedObject; ILinkObject path1 = intelligentObjects.CreateLink("Path",sourceObject.Nodes[0],serverObject.Nodes[0],null) as ILinkObject; ILinkObject path2 = intelligentObjects.CreateLink("Path",serverObject.Nodes[1],sinkObject.Nodes[0],null) as ILinkObject; [Execute] Move the source object intelligentObjects["Source1"].Location = new FacilityLocation(-4.5, 0, -2); [Execute] List all the nodes on the server object foreach(var node in serverObject.Nodes) { WriteLine(node); } [Execute] List all the objects in the model foreach(var ob in intelligentObjects) { WriteLine(ob.ObjectName); } [Execute] ---------- Hopefully you find this useful. If you improve the tool using the Source Code given then could you please repost the source code here in this forum topic. I'm sure that there are many things that can be improved by a proper programmer. What it really needs is intellisense . SimioREPL Source.zip SimioREPL UserExtension.zip

Here are some quick instructions: 1) You will need to have Microsoft Excel on your computer. 2) Download the "ImportsObjectsAndLinks.xlsx" and populate it with your model. 3) Extract "ImportObjectsAndLinksFromSpreadsheetAddIn.dll" from the "ImportObjectsAndLinksFromSpreadsheetAddInDLL_V5.zip" into a temp folder (e.g. c:\temp). 4) Right-click the assembly and select properties. Then choose to "unblock" button and press apply. (only needed for Windows 7 and later). 5) Copy "ImportObjectsAndLinksFromSpreadsheetAddIn.dll" into "C:\Users\\Documents\SimioUserExtensions". You might need to add the SimioUserExtensions folder under MyDocuments (C:\Users\\Documents) if it does not already exist. 6) Open Simio. Create a new Model. 7) From the Project Home...Select Add-In button, select "Load Objects and Links from an external spreadsheet" Choose the "ImportObjectsAndLinks.xlsx".

I haven't done routing using tables, but I have definitely done server based decisions where each server had a row in the table. And things from server properties to parameters used within the server logic were also in the same row. The search step in conjunction with logic that tells you what the parent object you are in is.... works wonders. It is a staple form of modelling for me now. It is far easier to control parameter values from a table, than via the UI. As to the usage of the API... as you might guess... the API is not advanced enough to create or even edit models. All of the model development is done via the GUI, and a single experiment is created (with relevant properties to drive it), as experiments can't be created via the API either. The API is then solely invoked to change the parameters in the experiment, and run the experiment. The CSVs written out from the experiment are then sucked into the program, and processed and displayed in graphs or available to be spat out into pre-made excel sheets. This reduces the requirement of running a model from needing knowledge of excel + simio (quite a bit of knowledge is required here), to solely needing to run the one custom app and understanding what all the parameters you change do (API can't pull out definition descriptions). The custom app obviously uses the Simio API, but at no time requires the user to open the Simio GUI or touch the model directly. It won't mean much, but attached are a few screenshots of what kind of data we put in and get out using the custom tool. As you can see, you can add multiple scenarios in, and do the same kind of scenario comparison, and even look at what is happening Gannt chart wise.

Hello, I am interested in having routing information read into a model from an Excel spreadsheet. The basic problem is that I have several entity types that must be processed at one of many servers. There are capability restrictions (i.e. EntityA can only be processed at Server1, EntityB can be processed at Servers1, 2, 3, etc). I have a “capability matrix” as input data that is a table in Excel showing where each entity type can be processed. In the Simio model, I am using a transfer node to route each entity to an available (and capable) Server by using the “Select from list” entity destination. My customer is interested in analyzing the impacts of changing capabilities of the servers. Currently, all other inputs to the model are fed in using bound Excel files. However, the routing logic requires lists, which I have to manually create and/or edit. I would like to have these bound to a data table, or somehow reflect the data in the master input Excel file. Thoughts? Thanks, Adam

Yeah, running models from bound Excel files is not seamless. However, even that doesn't do what I'm after (unless I'm missing something). I would need a way to get data from the table (bound to an excel/csv file) into a list. Alternatively, I need a way to get the transfer node (or routing group) to select locations from a table. Would you mind summaraizing your workflow for using the API for input data? Do you build the model in the GUI and create properties for all your input data? What is your typical input data like? Just curious if I could use a similar approach... Thanks! Adam

Assuming you have a property or state named TargetTime, then you could delay each individual entity by "TargetTime-TimeNow". Regardless of the times that individual entities arrive, they will all finish their delays at TargetTime and then move forward together.

Thanks for clearing it up. I did a quick forum search and this was the only relevant post I found. I was a bit disappointed in the stance on experiments. I would have thought the ability to run, but not create experiments to be more fair (for Team edition and higher). I guess we are either going to have to drop support for experiments in our team models, or buy an express license.

The post you quoted was over 3 years old (now updated a bit) and lots of things have changed since then including we moved to a new (.com) web site, renamed the existing Enterprise edition to Team Edition, then a year later came out with a new product named Team Edition. Somewhere along the way we introduced a new product named Express Edition which, among other things, can serve as a full runtime that supports experimentation. Here is an excerpt from our current documentation: Description of Runtime Capability Runtime is the ability for people to execute a Simio model without investing in that design-time version of Simio. Simio imposes no limits to the number of models you can distribute or the number of people you distribute to. And you are free to distribute outside of your organization if you choose. There is no charge for any such distribution Two runtime modes are available: Interactive Runtime Uses Simio Evaluation Version which is available free to anyone and may be used without activation. It provides the ability to load a model, run it interactively to view the animation, and even change the model at will. Model changes cannot be saved nor is the capability provided to run experiments or execute custom user-written steps and elements. Only Simio Team Edition (or higher) is capable of creating models that will run in Interactive Runtime. Full Runtime Uses Simio Express Edition. In addition to the substantial modeling features built into Express, it provides the ability to load and run models, save model changes, run experiments, and execute custom user-written steps and elements. Design, Team, and Enterprise Editions can create models for use with Full Runtime.

I'd try creating the file element from within a write step in the lower level object using "Create New". Once it is created, place your object on screen then enter your file name in the newly added property. All the best,

Slightly off topic, but I have never seen a model with a dynamic number of servers. Are you spawning servers on initialisation? And if so, should I assume you are using freespace? I make frequent use of dynamic entities and vehicles in freespace, but have never had much luck in terms of servers etc. I am sorry if I was ambiguous, I am not changing the number of servers, rather the number of entities within the servers at the starting time. I am not working in freespace.

Slightly off topic, but I have never seen a model with a dynamic number of servers. Are you spawning servers on initialisation? And if so, should I assume you are using freespace? I make frequent use of dynamic entities and vehicles in freespace, but have never had much luck in terms of servers etc.

Simple approach: Take advantage of the fact that each model has an OnRunInitialized process that is called at the start of each run. --Create a table that contains all your initialization data. This might optionally be bound to an external file and automatically read if it changes frequently. --Define the OnRunInitialized process to search that table, create the entity(s), initialize the entity, and transfer it to the correct location. Look at the Simio Example (not SimBit) named RPsixample for an example of this approach applied to a simple scheduling model. More comprehensive approach: Take advantage of the fact that each object has an On Initialized add-in process that is called at the start of each run. --Create a table that contains all your initialization data identified by object instance. This might optionally be bound to an external file and automatically read if it changes frequently. --Define the On Initialized process to search that table for a matching object instance, create the entity(s), initialize the entity, and transfer it to the correct location. This can also set object characteristics as well, such as status, capacity, failure data, learning curve, … While this could be used by simply specifying the add-on process in each object instance, it is even more powerful if you create a custom object that includes a custom object-specific initialization process.

I thought it might be useful to share this step and object I use. I wrote a simple custom step (using some internet resources) a few months ago that allows me to take screenshots of my model. I then often stitch these screenshots together to create a video. Unfortunately this object doesn't seem to work when used as an outside library. This means that to use the object, it will need to be cloned/copied/subclassed straight into your model and then instantiated from there. I've attached: The object I use the step in The dll file for the step The Visual C# solution files for the step Simio PrintScreen Step VisualC#.zip PrintScreenDLL.zip Picturerecorder.zip Picturerecorder.zip

While an If like Dan suggested but with 30 clauses would certainly be tedious to create, I think you could do it once in a Function, perhaps named StringState that returns the string. Then in all of your objects you simply reference StringState. That's a good work around. I had forgotten about functions in this kind of situation.

While an If like Dan suggested but with 30 clauses would certainly be tedious to create, I think you could do it once in a Function, perhaps named StringState that returns the string. Then in all of your objects you simply reference StringState.

Thanks for the suggestion. It now takes 30 seconds runtime for 1 million ... tokens, I guess that would be. First time I try this low-level approach. I followed your instructions (begin-seize-delay-release-tally). Read the Reference PDF as well. Added a Resource1 though (so there was something to seize?). Can see utilization of Resource1 (seems correct at .8321), but no queueing stats and cannot find any results from that Tally Statistics. Will continue to try. Still, I find it slow. I have a Javasimulation of an M/M/1 that takes only 4 seconds to run 1 million customers (=tokens/entities in Simio). Each customer has to be generated, wait for a resource (seize), delay, release it and ends up in a sink (that tallies). Same computer. The javasim has none of the GUI that Simio has, but then, there's no GUI processing overhead in FastForward/experiment mode. And, the Javasim reports queue and worker statistics (mean, variance). Perhaps Simio is collecting excessive statistics (if so, can it be turned off)? Or is it that I made a mistake by adding a Resource1 (to be seized)?

You can use Simio at several levels. Here are a few: • You can build simple models entirely within a Process (limited or no use of library objects). • You can use the Standard Library. This was designed to make it easy to do the more common applications, but is not intended to do everything. This library will be enhanced and supplemented with other libraries in the future. • You can enhance the Standard Library Objects via add-on processes. This functionality is still under development, but processes will be easy to define to supplement the OnEntry and OnExit behavior. For example, you may want to collect and report custom statistics or have custom exit logic. • You can enhance/replace the Standard Library Objects by inheriting from them and modifying any of the predefined behavior. For example the Server currently only allows a single failure stream. You could create a new MyServer object that reproduces the included logic to support three failure streams. • You can create entirely new objects by inheriting from base class objects (like Fixed Object, Link, Node, and Intelligent Object). With this approach you can graphically define any combination of properties and behavior that you want using Steps and Elements inside Processes.

We are now sponsoring a blog to help each other become more successful in our simulation projects. We will be sharing information and initiating discussions that will prove interesting and helpful to both experienced and novice simulationists. If you are not experienced at "blogging" let me assure you that it is pretty easy to participate. 1) You can just check http://www.simio.com/blog from time to time and see what's new. 2) If you don't want to miss any content, you can sign up for the RSS feed. This will result in an email automatically sent to you with each new post (approximately weekly). To sign up, look for the RSS link at the very bottom of the blog pages or in your toolbar. Or simply go now to http://www.simio.com/blog/feed. 3) For the most enriching experience, participate! Look at the end of each posting for a link to enter your comments. Or if you want to suggest topics or even post your own topic, contact me - I'd love to have your participation. This blog is not about Simio or any particular product, nor is it intended to be in any way commercial or sales-oriented. Success in Simulation is available to all simulationists, as well as anyone who wants to become a simulationist or who just wants to learn more about simulation. While we expect to focus mainly on discrete event simulation, articles on the related fields of agent-based modeling, system dynamics, and emulation will also be included. The articles will be intentionally be kept short for a quick read, and will be written in an informal style for easy reading. I encourage you to subscribe to the RSS feed so that you will automatically receive new articles as soon as they are posted.

A common way to create object definitions in Simio is by combining other objects, for example combining machines and a robot to define a work cell object. This type of object is called a composed object because we create this object by combining two or more component objects. This object building approach is fully hierarchical, i.e. a composed object can be used as a component object in building higher level objects. A second, more basic method for creating objects in Simio is by defining the logical processes that alter their state in response to events. For example, a machine object might be built by defining the processes that alter the machine state as events occur such as part arrival, tool breakdown, etc. This type of modeling is similar to the process modeling done in traditional modeling systems in use today such as Arena or GPSS. An object that is defined by describing its native processes is called a base object. A base object can in turn be used as a component object for building higher level objects. The final method for building objects in Simio is based on the concept of inheritance. In this case we create an object from an existing object by overriding (i.e. replacing) one or more processes within the object, or adding additional processes to extend its behavior. In other words we start with an object that is almost what we want, and then we modify and extend it as necessary to make it serve our own purpose. For example we might build a specialized drill object from a generalized machine object by adding additional processes to handle the failure and replacement of the drill bit. An object that is built in this way is referred to as a derived object because it is sub-classed from an existing object. Regardless which method is used to create an object, once created it is used in exactly the same way. An object can be instantiated any number of times into a model. You simply select the object of interest and place it (instantiate it) into your model.

The Simio object framework is built on the same basic principles as object oriented programming languages; however these principles are applied within a modeling framework and not a programming framework. For example the Microsoft development team that designed C# applied these basic principles in the design of that programming language. Although these same principles drive the design of Simio, the result is not a programming language, but rather a modeling system. This distinction is important in understanding the design of Simio. Simio is not simply a simulation modeling tool that is programmed in an OOP language (although it is programmed in C#). Likewise it is not simply a set of classes available in an OOP language such as Java or C++ that are useful for building simulation models. Simio is a graphical modeling framework to support the construction of simulation models that is designed around the basic object oriented principles. For example when you create an object such as a “machine” in Simio, the principle of inheritance allows you to create a new class of machines that inherits the base behavior of a “machine”, but this behavior can be modified (overridden) and extended. Whereas in a programming language we extend or override behavior by writing methods in a programming language, in Simio we extend or override behavior by adding and overriding graphically defined process models. This distinction between object oriented modeling and object oriented programming is crucial. With Simio the skills required to define and add new objects to the system are modeling skills, not programming skills.

Simio is a simulation modeling framework based on intelligent objects. The intelligent objects are built by modelers and then may be reused in multiple modeling projects. Objects can be stored in libraries and easily shared. A beginning modeler may prefer to use pre-built objects from libraries; however the system is designed to make it easy for even beginning modelers to build their own intelligent objects for use in building hierarchical models. An object might be a machine, robot, airplane, customer, doctor, tank, bus, ship, or any other thing that you might encounter in your system. A model is built by combining objects that represent the physical components of the system. A Simio model looks like the real system. The model logic and animation is built as a single step. An object may be animated to reflect the changing state of the object. For example a forklift truck raises and lowers its lift, a robot opens and closes its gripper, and a battle tank turns its turret. The animated model provides a moving picture of the system in operation. Objects are built using the concepts of object orientation. However unlike other object oriented simulation systems, the process of building an object is very simple and completely graphical. There is no need to write programming code to create new objects. The activity of building an object in Simio is identical to the activity of building a model – in fact there is no difference between an object and a model. This concept is referred to as the equivalence principle and is central to the design of Simio. Whenever you build a model it is by definition an object that can be instantiated into another model. For example, if you combine two machines and a robot into a model of a work cell, the work cell model is itself an object that can then be instantiated any number of times into other models. The work cell is an object just like the machines and robot are objects. In Simio there is no way to separate the idea of building a model from the concept of building an object. Every model that is built in Simio is automatically a building block that can be used in building higher level models.