Search the Community

This is my first time using this forum so I hope I am posting this in the correct section. I am currently busy with a problem involving the dust suppression program at an open pit mine. In open pit mines water trucks are used to maintain the condition of haul roads and reduce mine dust. Water trucks load water from refilling stations and traverse the road to spray water. After the water is exhausted, the water truck travels toward one of water stations for refilling and then continues to traverse the roads to satisfy the watering patterns. The water trucks run 24 hours per day.In practice the watering frequency of each road is related to the traffic intensity of haul trucks. The period of effectiveness, after the road has been watered, can range from 30 minutes to 3 hours. Regular light watering at approximately 0.3-0.5l/m2 is much more effective than infrequent heavy watering. To simplify the problem each road will be assigned a watering frequency (e.g. every 60 minutes) and a sliding time window (e.g. 10 minutes). The water can therefore be sprayed on the road within the given time window (e.g. 50 to 70 minutes). If the trucks service the road more frequently than every 50 minutes the road will be over watered and this can cause a host of problems. If the trucks water the road less frequently than every 70 minutes dust aggregation will start becoming problematic. In order to satisfy the water demand of the roads, it is possible that a truck waters a road segment first, then travels along the next road segment without watering it, and then waters another road segment. The road segment that a water truck traverses without watering is called a dead heading. A bidirectional road has to be watered in each of the two directions Empty water trucks are refilled at the refilling stations. A refilling station can serve a limited number of trucks at the same time. Also, a limited number of trucks can wait before being refilled. Hence, every refilling station has two kinds of capacities: the capacity for refilling the trucks and the capacity for holding trucks. If a refilling station is overloaded, some trucks need to be reassigned to a different refilling station. My main problem at this stage is how to model the dust aggregation on the haul roads. I started by setting up each road as a source server sink and then only displaying the server queue. The entities can then be modeled as dust clouds. The trucks then tend to the servers as operators. This still does not give the desired outcomes. I’m struggling to schedule the trucks to move on the shortest route and then return to the nearest filling station once they have depleted their water supply. Does anyone have any other ideas on how to approach the problem? Thanks for your help! Regards Carl-Gustaf Gericke

This is a very cool library, i have built two very simple examples to test before using it in a simulation in which they will represent Ship to Shore Cranes. First of all, it took me a moment to figure out that "entity destination" on my home node for the crane has to be set to "specific", can this work using "continue" ? Now, on attached example 1, the Crane picks the entity and will wait for an available vehicle to make the transfer, building a queue in the home node for the crane if there is no available vehicle. This is great since it reflects what happens in the actual operations, the crane waits for a truck to be below the crane to drop the container. crane_example1.spfx But there may be interest in simulating the crane dropping the entity into the floor and just keep unloading the ship, this means i now want to drop the entity without the vehicle being available. Is it possible to control this behaviour at will? I was looking for the option of an input buffer of some sort but for now I just add a normal node and allow the crane to drop it there it will build a queue waiting for the vehicle, this can be seen on example 2, I appreciate any ideas, crane_example2.spfx also, I tried scaling the elements and it gave me an error on height, so I was wondering what should i take into account when scaling (changing size) of this elements? I will take a screenshot next time I encounter the error. finally, I will be using this element in my simulation, and i was wondering what are the thoughts on "tulach" question: "5.) Crane and other crane components do generate a lot of data in trace. It would be nice to have possibility to swich this off just for some steps inside crane and co. I used it in a model that has a simulation time of 1 month and this made my trace impossible to filter and analyse." thanks best regards

Hi, I tried this library and it is a nice thing to work with. Few suggestions: 1.) It took me some time to get the difference between ForwardandBack and LeftandRight. 2.) Crane can, to my great suprise, transfer entities to nodes out of Bay. This happens only if the node is outside bay in the direction of cab movement. If it is outside bay in the direction of Bridge movement, warning appears. 3.)If Crane initialnode must be the same as bridge initialnode, it should be nice to have this set by default. This is not possible in Simio at the moment I think. 4.) It would be nice to have transparent Bay with borders only (Or a choice to . Sometimes we have layout of factory and bay does not look good and hides important things on layout. Ok I found that I can change bay as any other object but still transparent color for objects would be nice. 5.) Crane and other crane components do generate a lot of data in trace. It would be nice to have possibility to swich this off just for some steps inside crane and co. I used it in a model that has a simulation time of 1 month and this made my trace impossible to filter and analyse. 6.) If I have Bridge1 initialNode and CraneInitialNode the same as node where my entities go to be transfered, I get this error. I has something to do with fact, that bridge does not have to move, so it has movement.rate == 0 7.) In one model the lift started to fall into depth. This happens if entity has destination node set to specific and to the same node where it is. (e.g. if TransferNode1 is set to Entitity destination type specific, NodeName = TransferNode1) then crane will fall in the depths.

Sure. You can make tightly coupled servers by connecting them with a Connector and having Server1 output buffer capacity and Server 2 input buffer capacity set to 0. But it sounds like you want more loosely coupled servers, so for example you could set: -Server1 Output Buffer is 0 (nothing waits there) -Path2 Capacity is 1 (only 1 can wait there) -Server2 Input Buffer is 1 (only 1 waits there) -Server1 Capacity is 1 (only 1 can be there) So you can have a total of up to 3 entities in or on the way to Server 2. Beyond that Server1 will be blocked and and additional entities will wait in Server1 Input Buffer. (I would have attached a model if you had posted this in an SI folder, but attachments are limited in these public folders.)

Pedro, pretty sure you can use transfer or destroy.

Hmmm, actually he didnt update the model, it works fine. What is the correct way to remove elements from a station? I can perhabs use transfer right? Can I destroy them?

Hi! I have this: Configurations are like: Then I have the station's contents being displayed in the External definitions. I can count the new entities entering the station.contents, but they don't visually appear in the queue... What am I doing wrong? Thanks!

The attached model relates to the discussion at the following post: http://www.simio.com/forums/viewtopic.php?f=1&t=1165 I created a very basic, not quite fully functional, 'dwell time' model that calculates the dwell time based on how soon the next departure slot is according to Dave's example above. I don't feel this approach is very elegant but it can help others get started. sampleDwellTimeModel.spfx

I don't think you can dynamically create nodes while model is running, or at startup. So I think you would need to have a single input node, and output node, which you could then follow up with a single node that you could put all your pathing logic in. In that node, you could tell all of entity type A to go down path1, and all of B to go down 2, etc.

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.

Modeling multiple cranes on a common (shared) runway is hard to do well. Still harder when you take into account acceleration, crane blocking, and good 3D animation. If you have encountered this problem, here is a solution. For standard bridge crane movement, we recommend the simpler Crane object in the Extras library. But if you need the underhung cranes with cabs moving between bays, read on... The Simio Crane Library is a collection of objects designed for modeling multiple cranes operating simultaneously in a bay. The library is provided as an example of complex material handling using the standard features of Simio. The Crane library may be used in conjunction with the Simio Standard Library, and Crane pickups are done using the standard TransferNode (e.g. the output side of a Server). Crane drop-offs can be done at either a BasicNode or TransferNode. The Crane Library can also be used with custom libraries as long as they support rider pickups using the standard transporter ride features. The Crane Library consists of objects representing the Bay, Bridge, Cab, Lift, and Crane (the end effecter that actually picks up and drops off the item). These objects are combined together to model multiple cranes moving in a single bay. The separation of objects in this way allows you to use your own symbol for each component. A Crane movement occurs by first rising up from the pickup node to a specified travel height, traveling laterally at that height, and then lowering down to the specified drop-off node. All travel is done through free space without the need to explicitly draw a network. The Crane library also fully supports independent acceleration/deceleration and the ability for one crane to cause another blocking crane to move out of the way. The above library file is now obsolete. Instead, download the library posted closest to the bottom topics. 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.

The Combiner object in the standard library assumes that you have a parent entity representing a box or container and members representing the parts that are combined into the parent. In some cases you don't want to have a parent, you just have a number of entities that you want to temporarily join together and process as one. The attached project contains an object of type Node that represents a very simple Combiner and a TestModel to illustrate how it works. The node simply asks for a Batch Size and then holds the incoming entities until that batch size is reached. It creates a "normal" batch so it can be used with the Separator as long as you treat all outbound entities as the same. CombinerNode.spfx Requires Sprint 5.80 or later.

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

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

So this may be an easy answered question, but I'm at a roadblock. I want to have an entity wait in a server until a specific date and time. Once that date and time is reached within the model run, I need it to fire and move to the next server. This would be easy if it were one entity, but essentially a batch all arrives at different times and then needs to wait until that date/time to ALL move at the same time into a combiner. Any help would be greatly appreciated.

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

Simio LLC uses software activation to enable advanced Simio software capabilities. A customer and product-specific activation code is supplied based on the products and number of seats purchased. During application of the activation, a one-time automatic (or optionally manual) contact between the customer computer and a Simio license server validates installation of the product on a specific machine and replaces the customer-specific activation code with a machine-specific activation code. While this final activation code is not intended to move between computers, when necessary Simio can assist customers under current support with making such a move. Node-locked Licensing (restricted to one computer) For node-locked activation, Simio LLC uses software from the Infralution company. Node-locked activation is locked to a single user computer. While it is intended for a single user, it can also be shared by several people who alternately share one computer. Simio software must be installed on the machine with the activation. Server Licensing (shared via a central server) For server-based activation, Simio LLC uses software from the Reprise company (by the same people who invented the popular FlexLM software). Server-based activation is locked one or more servers, but those servers can in turn manage the sharing of activations across an unlimited number of clients who have access to the servers via an internal, external, or VPN network. This provides a very convenient mechanism for sharing a small number of licenses across a larger number of users. For example a 5-seat server license could be shared by 20 or more users as long as only a maximum of 5 concurrent users are sharing licenses at one time. In addition, Reprise allows users to “borrow” a license to their machine for use while off network (e.g., while traveling), or for dedicated use for an extended period of time (e.g., to implement an important project). Both the duration and availability of borrowing is under administrative control. Reprise does require a server that is available to all potential users. But Reprise puts only very small demands on the server for both disk space and processor load. Simio simulation software need not be installed or run on a server, only on the client machines.

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

Ever have a rectangular box moving short edge first on one conveyor and then connect at a 90 degree angle to another conveyor on which you want it to ride long edge first. This rather flexible object will do that in any orientation. And has a few extra options as well. Part of the "trick" is to have two pictures of the same object oriented off by 90 degrees. Use this as is or as a basis for your own customized object. (Requires sprint 68 or later) Someday this may involve into a SimBit with a full explanation, but in the interim, enjoy. TransferDeviceSimBit.zip

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

This is something I have been meaning to implement for a while, and now have finally decided it needs to be done. I have a submodel, and due to the limitations of the software can't transfer it into the submodel and keep the model clean. I followed advice posted here, and have made the submodel seize the worker and send it to a node in the higher level model... while the submodel is in progress. Is there a nice efficient way to have the worker/vehicle (vehicles are the new worker in terms of having all the functionality i require) able to interrupt the submodel and either remember where it was up to and return after break... or allow another seize request for a different worker, and have that worker continue where it was left off?

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.