Simantha (simulation for manufacturing) is a package for simulating discrete manufacturing systems. It is designed to model asynchronous production systems with finite buffers.
The package provides classes for the following core manufacturing objects that are used to create a system:
- Source: Introduces raw, unprocessed parts to the system.
- Machine: Continuously retrieves, processes, and relinquishes parts. May also be subject to periodic degradation, failure, and repair.
- Buffer: Stores parts awaiting processing at a machine.
- Sink: Collects finished parts that exit the system.
- Maintainer: Repairs degrading machines according to the specified maintenance policy.
- Part: Goes through the production systems, from source to sink, and stores the name of each source, machine, buffer, and sink visited by the part.
Simantha is a discrete-event simulation package written in Python that is designed to model the behavior of discrete manufacturing systems. Specifically, it focuses on asynchronous production lines with finite buffers. It also provides functionality for modeling the degradation and maintenance of machines in these systems, as well as quality indicators and (machine) routing histories for part objects that go through these systems. Classes for six basic manufacturing objects are included: source, machine, buffer, sink, maintainer, and part. These objects can be defined by the user and configured in different ways to model various real-world manufacturing systems. The object classes are also designed to be extensible so that they can be used to model more complex processes.
In addition to modeling the behavior of existing systems, Simantha is also intended for use with simulation-based optimization and planning applications. For instance, users may be interested in evaluating alternative maintenance policies for a particular system. Estimating the expected system performance under each candidate policy will require a large number of simulation replications when the system is subject to a high degree of stochasticity. Simantha therefore supports parallel simulation replications to make this procedure more efficient.
The original version of Simantha can be found at https://github.com/m-hoff/simantha. This version extends a few capabilities and examples to prepare it for the modeling of condition monitoring systems and prognostics and health management tools.
The software is available for public use through a publicly available Github repository. Any user with a Github account may create a fork (copy) of the repository to freely experiment (e.g., object class extensions to model complex processes) with the code without affecting the original source code.
For the complete Simantha documentation, see https://simantha.readthedocs.io/en/latest/ . Here, you will find:
- Reference for all the objects in Simantha
- Examples of discrete manufacturing system models
- Use cases that extend Simantha for such things as condition-based maintenance
Simantha and all of it's associated projects are in the public domain (see License). For more information and to provide feedback, please open an issue, submit a pull-request, or email the point of contact (below).
Simantha can be installed via pip using:
pip install simantha
Alternatively, after downloading a local repository (for example, via cloning a fork), go to the directory of the clone in the project environment and install Simantha with the following command:
pip install .
Using Simantha requires Python ≥ 3.6 and, optionally, SciPy ≥ 1.5.2 for running the included tests.
The following is an example of the creation and simulation of a simple two-machine one-buffer line.
from simantha import Source, Machine, Buffer, Sink, System
# Create objects
source = Source()
M1 = Machine(name='M1', cycle_time=1)
B1 = Buffer(name='B1', capacity=5)
M2 = Machine(name='M2', cycle_time=1)
sink = Sink(collect_parts=True)
# Specify routing
source.define_routing(downstream=[M1])
M1.define_routing(upstream=[source], downstream=[B1])
B1.define_routing(upstream=[M1], downstream=[M2])
M2.define_routing(upstream=[B1], downstream=[sink])
sink.define_routing(upstream=[M2])
# Create system
system = System(objects=[source, M1, B1, M2, sink])
# Simulate
system.simulate(simulation_time=100)
# Output:
# Simulation finished in 0.00s
# Parts produced: 99For additional examples, see simantha/examples.
This version of the tool is part of the Smart Manufacturing Industrial AI Management & Metrology project for Smart Connected Systems (Communications Tech Laboratory) at NIST.
Simantha has been developed by Michael Hoffman as a software package for the Python 3 programming language (originally at https://github.com/m-hoff/simantha), and is being maintained and extended here by Mehdi Dadfarnia & Serghei Drozdov:
- Mehdi Dadfarnia, Maintenance & Development
Citation examples can be found at: https://www.nist.gov/open/copyright-fair-use-and-licensing-statements-srd-data-software-and-technical-series-publications