dsturrock

I would probably sub-class Path to create your own custom path object - maybe call it DustyRoad. Then on DustyRoad you might add a Level State called DustLevel. Then it sounds like DustLevel would start at 0.0 and increase at a given rate. That DustLevel Rate could be a simple time function or a function of ambient temperature, average traffic level or anything else. You could also implement step changes to the current DustLevel Value each time a hauling truck travels it. And then I guess you would set the Value to 0 each time it is sprayed. At a simple level, each water truck or dispatcher could just look at the current DustLevel Value at any DustyRoad of interest. But you could make DustyRoad as smart as you wanted, perhaps having it call for spraying when it reaches a certain DustLevel Value (using a Monitor). You could have each DustyRoad record it's own average dust emission level in whatever form is appropriate and even roll it up to the Mine or model level for a measure of the overall effectiveness of your dust suppression strategy. For each feature you add to DustyRoad you would expose a property allowing users to customize the behavior. For example, you might have a property for the name of the state into which you roll up the dust emission statistic. This is an interesting problem. I'd love to hear/see how you make out with this.

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

Many of you are unaware of our development process. And in fact you don't really need to know about it beyond the fact that every time you look we have lot's more features than when you last looked. There are many reasons for this including an incredible engineering team and high customer involvement. But a significant part is due to our agile development process involving builds and sprints. Although we have extensive manual testing, our testing foundation is a suite of well over 5,000 automated tests applied each time before anyone can make any change to the software. If that change passes the test suite, it is commited and is automatically compiled, retested, and a releasable image suitable for distribution is created. The result of that process is called a "Build". Our recently passed milestone is that we have now created more than 10,000 releasable builds. Obviously those do not all end up in public hands. What we refer to as a "Sprint" is simply a three week planning cycle that consists of multiple builds. During each sprint we do additional manual tests as well as updating documentation and other product aspects like SimBits. At the end of each sprint we have tested, documented, distributable software including new functionality. Most customers don't download and install every Sprint. But we encourage you to do so when convenient so that you are always working with the best software, documentation and examples we can deliver. Most sprints are posted to the Simio Insiders download area. The public releases are updated approximately quarterly. Here are some of our major milestones and why we so rapidly pulled ahead of the competition: Sprint 1 – May 2008 (Initial public posting) Release 1.21 May 2009 (Initial release) Release 2.31 Dec 2009 (Major Release) Release 3.42 Aug 2010 (Major Release) Release 4.58 July 2011 (Major Release) Release 4.64 Dec 2011 (Enterprise Edition) Release 4.68 Apr 2012 (2012-13 Academic Year) Release 5.80 Nov 2012 (Major Release) Latest build is 5.87.10046 (as of this writing) 10,046 tested, installable Builds created We celebrated in the usual understated Simio fashion with the development team going out for gourmet coffee. Then back to work on the next sprint .

We have made lots of enhancements and additional features to this library. --It now supports limited blocking avoidance (one crane will move out of the way of another). --It supports acceleration and deceleration. --It supports a little bit of deadlock detection/prevention (but that is a huge field). --And it supports movement of cabs from bridge to bridge, even across buildings as permitted by the new style of Underhung Cranes. While Underhung Cranes aren't yet popular, they are really cool to watch (both live and animated) and there are many compelling benefits why we will start seeing a lot more of them. SO FAR, ONLY SIMIO CAN MODEL THEM! And since these, like all Simio objects, are open to view, you can see how this was done and use the same techniques to make your own compound objects like robots, lift trucks, and other mulit-part devices. Enjoy! (Requires Simio 5.86 or later) We are still anxious to receive your feedback on this library.

As noted in the initial post, there were some performance problems when it was used as a library, but those have since been fixed in recent Simio versions. So now you can load it as a project and just drag crane objects from your project library into a new model. Or you can load the crane libary as a library (Project Home ribbon > Load Library) and use it as a normal library. We are currently in quality control on some major enhancements to this library including features to deal with Blocking (moving another crane out of the way), Deadlock avoidance, and modeling Underhung Cranes (allow cabs to move between bridges and bays). Hopefully we will have that available to post within 2 weeks.

The Simio product and its documentation is obviously created in English but we would like to expand that availability. Software As of this writing (April 2013) the Simio software is currently available in English and German. But the software has been designed from the start to be translatable. In fact we can quickly create a Google translation in any language, but unfortunately while that can be a good start of a translation, it's accuracy is not good enough to serve as a finished product. So we are looking for any volunteers who would like to see Simio in their native language. Textbooks We currently have book translations in Spanish (both books), Portuguese, Mongolian, and Italian. We are looking for additional translations and the translator(s) will be acknowledged as co-authors on the translated edition. Royalties will also be shared, but given the relatively small quantities and low book price your motivation should probably be mainly "fame and glory". Training and Other Materials Volunteers have also translated selected training and other supporting materials. We are always anxious to have this type of user participation to help the broader community. Existing and new materials will be available in this forum. Software Features A few features have been added to the software to make it easier to use in other cultures. One such feature is a setting to control the separator character used in CSV files which now defaults to your systems culture setting. Please let us know if additional such features are necessary. If you or your team are interested in helping with any of the above, please contact me directly. (dsturrock@simio.com)

James Doran, along with Dave Sturrock and Dennis Pegden, is shown wearing and hoding some souvenirs from Simio.

I want to publicly thank: James Doran, Mining Systems Modeler, Anglo American James has made tremendous contributions to this forum. His tagline reads: Resident Problem Synthesiser and he has done plenty of that... he has often been a pain in the, um, er, keyboard as he pushes and stretches Simio to do more things with it. Sometimes this means reporting bugs or asking difficult to answer questions . But more often he identifies opportunities to improve Simio and posts them to give us a permanent record as well as the opportunity to collect other user feedback. Along the way James has accumulated a great knowledgebase and he is always forthcoming to share that knowledge with others. He often steps in to answer problems posted by novices and experts alike and often contributes to interesting discussions. On behalf of Simio and our user form members - THANK YOU JAMES DORAN! You have made significant contributions to both the Simio forum and the Simio software. A small token of our appreciation is on its way to you.

No, if it is a Simio symbol, see item 5 in the above post. If you are talking about your own symbol, then you need to go back to the source to get it. If it is in someone else's model (their custom symbol) then you need to contact them - it may be public or proprietary.

1) Start by representing your Pressure and Temp as States of type Level (see Definitions > States). These state values can continuously change based on the value of a rate. Setting that rate to +, - or 0 is something you can do wherever appropriate in your model. (Example: have a state named Pressure, and assign Pressure.Rate to its rate of change based on what causes it to rise or fall). 2) Create a Monitor for each State (Definitions > Elements) of Type CrossingStateChange with an appropriate Initial Threshold Value. When the value of the state being monitored crosses the threshol value, it automatically triggers an event named MonitorName.Event. (Example: have a Monitor named PressureExceeded and set its threshold at a maximum pressure allowed (e.g. 250)) 3) If you just had a single monitor, then on a Server you could specify reliability logic with a failure of type Event Count Based and use the event from that monitor (Example: Fail each time PressureExceeded.Event occurs). You don't say if you intend to use a Server or a custom machine. The basic approach above will work in either case. But to deal with multiple sensors might require some custom processes or a custom object because the Server is designed to deal with only one failure stream. There are several ways of approaching multiple failure streams depending on your objectives. Here is a simple model in 5.81 to illustrate:ServerFailsBasedOnSensor.spfx

I have a slightly different perspective. I absolutely do NOT just jump in, but it may appear that I do since I start modeling in Simio almost imediately. I strongly believe in having a functional specification (FS) for each project. This is one of the first things I do. And part of that FS is doing a prototype. While you could use many different tools for prototyping/conceptualizing, I find that using Simio itself offers several advantages. There are multiple goals to the prototype including: --Understanding the big picture --Understanding the potential gotcha's (not just technical ones) --Exploring scope and completeness --Communication between modelers and stakeholders In the ideal situation, the prototype is a simple representation of the system that looks and behaves similar enough to the real system that it helps stakeholders understand the issues mentioned above. But it is not necessary that it actually run, and it sometimes won't look much like the real system. It will NEVER provide useable results (e.g. answers) beyond the goals mentioned above. In most cases this prototype becomes a throwaway after it has met its goals, but if you are lucky, it may be close enough to the mark that you can use the prototype as the basis for the real model. The FS process takes time (perhaps 5-10% of the total project time) but it is NOT EXTRA TIME! The FS process just moves some of the most important parts of the project into the early stages where it can dramatically improve the success of the project. I have written several treatments of this approach. One can be found here: Simio and Simulation - Modeling, Analysis, Applications 6th Edition | Simio

Just for fun I did a Lotto object that can meet this need. It simply keeps track of what samples have already been generated and prevents reusing a number. LottoGenerator.spfx

Actually it was doing that at one point and then we fixed it. Seriously, that isn't a typical behavior of cranes sharing a runway, but I could see that some cranes might allow that. The point of this library is to provide cranes that work together as a system. But that might be an optional behavior that could be implemented in a future library or it could certainly be added as a specific user variation of the library. Or, depending on how interdependent they are, you might just model your system as multiple (sets of) cranes that just happen to operate in the same space.

Yes, that is definitely important and in our future plans. We are waiting for feedback from early users before we prioritize the next set of enhancements.

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.

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.

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.

Simio has a number of enabling features that are not widely known. When you save a project file, most people use the .spfx extension which is a compressed binary file. But if you would like to take advantage of a version control software (VCS), you generally want the VCS to manage versioning and file compares and file compression, itself. Simio has a multi-file project format referred to with a .simproj extension, which is designed with exactly that purpose in mind. Ths format involves a single key simproj file and a related set of folders that contains the uncompressed version of all the included components. This allows VCS to recognize when a small change to your model is made that it only needs to save that small change and not the entire model. While this works with any VCS, internally at Simio we use Tortoise SVN (http://tortoisesvn.net/) which works quite well for us. Simio also has some built-in features to help track and maintain model/library versions. If you right-click on an object (a model) and select "Properties" you will see a set of model properties for that object including Version. This version number is referenced when loading this object as part of a library to help evaluate if an object has been changed and if the change should be accepted (more on this below). Some additional model properties including Description, Keywords, and Categories. These are available in your model, plus they are available externally. For example the Sample SimBit Solutions interface uses these properties to help you quickly find a SimBit of interest. Some of them are also used in the Model Documentation Report. Speaking of which, the Model Documentation Report is designed to provide a quick way of examining all non-default parameters in your project. It can be useful to instructors evaluating assignments or as a way to record or share a snapshot of your model data. If you click on your Project name in the navigation window, the click on Models and the Edit ribbon you will see various options for subclassing, cloning, and copying library objects. These options, while subtle, give you greater control over how the lineage of an object wil be handled. You will also see options on this ribbon to protect your object from viewing and editing, and also to describe changes that have been made with the latest version.

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.

You can explore the contents of the Simio Standard Library by subclassing any object. You can do that by clicking on MySimioProject in the navigation window or by right clicking on any library object and selecting Subclass. The file itself is StandardLibrary.spfx and can be found in the MyDocuments\SimioModels folder. You should not change this file as it is automatically (re)generated any time its contents do not match what is expected.

Here are a few simulation blogs I am aware of. Please reply with other good ones if you know of any. Simio-Related: * http://www.simio.com/blog/ * http://blog.kimesolutions.de/ * http://simiosimulacion.wordpress.com/ (Spanish) * http://www.jsmith.co/ Other: * http://www.simventions.com/boms/blog/ * http://www.simulation.org.uk/news.php

The standard library vehicle has the option of a loading and unloading time per entity, but it is often difficult to model a situation where a vehicle stops for a specified time (like a bus or train). This object (with an example model) adds a single reference property and a single step to the standard Vehicle to allow you to specify that time. Smple, but convenient. VehicleWithFixedLoadTime.zip Done using Sprint 68

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

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.