Search the Community

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

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'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

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,

I am trying to model a server with several failures, where each failure may have a different explanation and thus, a different pattern. One obvious approach is subclassing a Server and defining additional elements, such as Failure, Timers, etc and modify the processes so that several failures can cause the downtime of the server. However, I do not feel very comfortable with the scalabitliy of this approach. I mean, if a server has three types of failures I will have to add two new Failure elements, 8 timers, 4 corresponding to each Failure and so on. If at some point in time I need to add an additional failure, I would need to do the adding all over again, an so on. I am considering two different approaches for this, but I do not know if these are feasible or if there is a far better approach. Approach 1. I would like to subclass the server and create a Repeat Group property so that the user, by means of adding rows, may characterize as many failures as desired. The thing is, is is possible to modify the processes so that they are general enough to reflect any number of failures (with their corresponding characterization)? Approach 2. I was thinking of creating a new object, let us call it objFailure, which contains definitions and processes to reproduce the behaviour of a failure type. The idea would be that this objFailure has a property which would contain the number of an element within the project, so that when objFailure fails, the corresponding object fails. This way, modelling a server with several types of failures woukd consist in creating that server and as many objFailure as required, which would cause the server to fail as they themselves fail. The issue with this approach is that it may not be that easy to represent interferences among failures. For example, if objFailure1 is a count based event failure and objFailure is a Processing Time based failure, when objFailure1 occurs, the server stops and the time during which is down should not be taken into account by objFailure2. This may very complex to program effectively and efficiently.

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.

Simio is a Simulation Modeling framework based on Intelligent Objects. This may be a bit different than other simulation packages that you may be familiar with, even those that market themselves as object oriented. Simio is designed from the ground up to support the object modeling paradigm; however it also supports the seamless use of multiple modeling paradigms including a process orientation and event orientation. It also fully supports both discrete and continuous systems, along with large scale applications based on agent-based modeling. These modeling paradigms can be freely mixed within a single model. 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. Simio is a family of products that includes the Design, Team, Enterprise and Portal Editions. Models built with the first three Editions are fully compatible both up and down the product family and provide the same powerful 3D object-based modeling environment. Many simulation packages are built on outdated 2D technology that limits your ability to visualize your process or capture 3D spatial relationships in your system. Some of these older products limit you to 2D only models, while others offer expensive/complex 3D add-ons that require you to build a separate 3D visualization of your system, and then tie these two separate components together. These extra steps add unnecessary work and time to your project, and make your model and animation difficult to edit and maintain. In contrast, Simio provides a true object-based 3D modeling environment which lets you construct your 3D model in a single step from a top-down 2D view, and then instantly switch to a 3D view of your system. You simply drag and place your 3D objects from an Object Library into your facility view of the model. All Simio model-building products directly integrate with Google Warehouse to allow you to quickly download from a massive library of freely available 3D symbols to easily and quickly add realism to your models.

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 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 and Team Editions can create models for use with Full Runtime.

We have added a Simio add-in that will import a model (objects and links) from a spreadsheet. The most DLL, spreadsheet and code are provided in a later post.. NOTE: You do not need the code to run the add-in. All you need is the ImportObjectsAndLinksFromSpreadsheetAddInDLL_V5.zip and ImportObjectsAndLinks_v5.xlsx. The code is also provided in case you wish to make changes to the add-in. You can run the addin just using the DLL and spreadsheet. All you need to unzip the DLL into C:\Users\\Documents\SimioUserExtensions. You might need to add the SimioUserExtensions under MyDocuments (C:\Users\\Documents) in case it does not already exist. Once you run the add-in in Simio, use the attached spreadsheet. It should create a Source, Server, Sink with an Entity and a Vehicle. If you want to use the code, you will need to update the project properties..under build. The output path needs to be C:\Users\\Documents\SimioUserExtensions...See attached screen shot. Give it a try. Let us know if you have any questions. Updated 2106-10-24.....Added support for repeating properties and wrapped import using BulkUpdate method to speed up import . ImportObjectsAndLinksFromSpreadsheetAddIn_DLL.zip ImportObjectsAndLinksFromSpreadsheet_Code.zip ImportObjectsLinksVertices.xlsx

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.

The attached model illustrates 2 concepts: 1st the ability to pick up Entities mid-route, 2nd how to create a 2 Task Selection Strategy when deciding who to pick up. In this model, there are high priority Entities (illustrated by the red Entities) that are created at HiPrioSource. These Entities are to be loaded first, even with low priority Entities waiting. And when the high priority Entity is loaded the vehicle takes it directly to the sink. However, when a low priority Entity is loaded, the vehicle is supposed to stop and pick up any other waiting low priority Entities that are waiting along the vehicle’s route to the sink. So, to maximize the number of Entities loaded, the vehicle wants to pick up at the farthest location (LowPrioSource1) so that it can pick up any waiting Entities as it passes through LowPrioSource2. Now the Vehicle chooses the next Entity to pick up based on its Task Selection Strategy where it can be Largest/Smallest Priority or Largest/Smallest Distance – but it can’t be both. In this example, we want to FIRST make the decision based on Priority, THEN if we know its low priority we want to base it on Largest Distance. Because we want to first base it on Priority we set the Task Selection Strategy to Highest Priority. This means that it will handle the first tier of the decision process for us. Creating the second tier requires us to customize the Standard Library Vehicle. So we subclass a Vehicle and add an Entity Reference State called ‘NextEntityToPickup’. Then we Override the OnVisitingNode Process in this new vehicle and about 2/3s of the way through the process, after Decide-IfIdel and before the Plan Visit-NewTransportationTask we place a Search step. This Search Step searches the QueueState ‘MyVehicle.CurrentNetwork.VisitRequestQueue’ (the queue of all waiting Entities) with a Search Type of ‘MaximizeReturnValue’ with a Return Value Expression of ‘MyVehicle.NetworkDistanceTo.Node(Candidate.Entity.CurrentNode)’ – meaning the Entity that is farthest away from me. This Step will find the farthest Entity out of all waiting Entities, so on the Found Branch we assign NextEntityToPickup the value of ‘Object’ – meaning the specific Entity that is farthest away. *Note, we have to reset the NextEntityToPickup State before this Search. Now, in the OnEvaluatingTranportRequest Add-on process we place a Decide Step with the following expression ‘Math.If((MyVehicle.ResourceState==0) && (MyVehicle.NextEntityToPickup != Nothing), MyVehicle.NextEntityToPickup == Entity, True)’ and a Reject Assignment on the False Branch. So, this expression says If the MyVehicle is Idle and there IS a value for NextEntityToPickup, Then “am I the next Entity to pick up?” (which gets evaluated by every Entity), if it is not idle or there is no value for NextEntityToPickup then continue on – the vehicle will pick you up. So, this combination of letting the Vehicle handle the Priority mixed with Finding > Assigning > and Checking the Farthest Entities will give you the 2 tiered Task Selection that was desired. Also, don’t forget that this Vehicle is supposed to pick up low priority Entities Mid-Route. Doing this requires further Customization of the OnVisitingNode Process. Right after the Execute-Entered Add-On Process Step we placed a Search Step that checks to see if there is any High Priority Entities in the Ride Station. If the Ride Station has a High Priority Entity OR it is completely empty, the process will continue on as normal. If the Ride Station is NOT empty and it is carrying a Low Priority Entity, that means we can try to pick up more Entities along the way. To do this, we just force the Vehicle to try to DropOff/PickUp at this node (which it would not do normally, unless it was at the dropoff node). If there are no Entities to pick up or drop off at this node, both the Pickup and Dropoff Nodes will fail and the token will eventually route itself out of the process and the Vehicle will continue on. If there are waiting Entities, the vehicle is forced to pick them up by avoiding the logic that would normally tell the Vehicle to exit the node. Custom Pickup Process.zip

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)?

As you have discovered (and I discussed in my post above), running an experiment puts Simio in its fastest run mode possible. And in this mode it will automatically distribute the replications and scenarios across all of your processors/cores. This alone can provide dramatic speedups. If you have Team Edition, you can actually extend that to use spare processing power in your work group. So if you have 4 quad-processor machines available on your local network, you can run up to 16 simultaneous replications or scenarios. In terms of modeling, the most dramatic improvement you could make is to build your model at a lower level. The model you described is simple to model entirely in a single process with steps: (begin) - Seize - Delay - Release - Tally - (end) with the process triggered by a Timer element and using TallyStatistics elements for any token-related statistics like Time In System. You would not even need to create any entities, it could all be done using tokens which are smaller and faster. The process approach should be many times faster.

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.