Jump to content
Simio Forum


  • Content Count

  • Joined

  • Last visited

  • Days Won


cdpegden last won the day on November 2

cdpegden had the most liked content!

Community Reputation

1 Neutral


About cdpegden

  • Rank
    CEO, Founder
  • Birthday May 27


Recent Profile Visitors

The recent visitors block is disabled and is not being shown to other users.

  1. 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.
  2. 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.
  3. 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.