JSON Single Server Example

This example provides the same model as in ManPy Single Server Example, but now the model is built in JSON and passed to ManPy as an argument.

The full JSON input of the model is given in \dream\simulation\Examples\SingleServerModelInput.json. Under node we have the simulation objects that correspond to Figure 2. For example, the Exit is defined as:

        
			"E1": {
				"_class": "Dream.Exit",
				"name": "Exit"
				}
		

Every entry in node describes one object and the key (e.g. "E1") is the id of the ManPy object that should be unique (no two nodes with the same id). The value is a JSON object that contains all the attributes. For E1 we have only two:

• class points to the ManPy class of the object. “Dream” is used as a convention to point to dream\simulation where generic ManPy components are. Nonetheless, an absolute path can also be used, e.g. dream.simulation.Exit.Exit (since Exit class is in dream\simulation\Exit.py)
• name: contains the name of the object.

In other elements we may have to input more parameters. For example in Queue we have the capacity:

        
			"Q1": {
				"_class": "Dream.Queue",
				"capacity": 1,
				"name": "Queue"
				}
		

For the Machine we need to define the processing time. This is given below:

 
			"M1": {
				"_class": "Dream.Machine",
				"name": "Machine",
				"processingTime": {
					"Fixed": {
						"mean": 0.25
						}
					}
				}
		

Note that the distribution is defined similarly to the style of when defining distributions using ManPy through Python (see ManPy Single Server Example).

Similarly we define the inter-arrival time for the source:

 
			"S1": {
				"_class": "Dream.Source",
				"name": "Source",
				"entity": "Dream.Part",
				"interArrivalTime": {
					"Fixed": {
						"mean": 0.5
						}
					}
				}
		

Under edge the connections between the object in the style of arrows are defined. Below we give example of an edge:

 
			"2": {
				"_class": "Dream.Edge",
				"source": "Q1",
				"destination": M1
				}
		

Again, the key of the object is the id of the edge that should be unique (no two edges with the same id). _class defines the class of the node. The default value is Dream.Edge. source defines the object that the edge starts from and destination the object that it points to.

Finally, generic information about the model is defined in general:

 
			"general": {
				"maxSimTime": 1440,
				"numberOfReplications": 1,
				"trace": "No"
				}
		

The above definition dictates that we have one replication of 1440 time units. No trace will be returned.

Passing this JSON to dream\simulation\LineGenerationJSON.py, the ManPy model is run and the result is returned. The full result is in \dream\simulation\Examples\SingleServerModelReuslt.json.

In the elementList we can see results that all simulation components return. For the Exit for example it is:

 
			{
				"_class": "Dream.Exit",
				"id": "E1",
				"family": "Exit",
				"results": {
					"throughput": [
						2880
					],
					"takt_time": [
						0.49991319444444443
					],
					"lifespan": [
						0.25
					]
				}
			} 
		

Note the family attribute. This can help if external software wants to group object types ( e.g. Exit and ExitJobShop) and process the results they return similarly.

All results like throughput are given in a list so that if we have many replications the results of all runs are returned.

Some objects can output specific stats only if the user sets a flag on. So for the Queue we can set gatherWipStat to 1 like below:

        
			"Q1": {
				"_class": "Dream.Queue",
				"capacity": 1,
				"gatherWipStat": "1",
				"name": "Queue"
				}
		

Then in the output the Queue will give a list like the below:

        
			{
				"_class": "Dream.Queue",
				"id": "Q1",
				"family": "Buffer",
				"results": {
				"wip_stat_list": [
					[
						[
							0,
							0
						],
						[
							0,
							1
						],
						[
							0,
							0
						],
						[
							0.5,
							1
						],
						[
							0.5,
							0
						],
						...
						...
		

The format of every entry is [simulation time, number of entities]. This way external software can collect the data and calculate statistics for the Queue, output graphs etc.