objects updated to read distributions newstyle

dream/simulation/Assembly.py

@@ -55,31 +55,22 @@ class Assembly(CoreObject):
         self.Working=[]
         self.Blockage=[]
 
-        # if input is given in a dictionary
-        if inputsDict:
-            CoreObject.__init__(self, inputsDict=inputsDict)
-        # else read the separate ones
-        else:
-            if not processingTime:
-                processingTime = {'distributionType': 'Fixed',
-                                'mean': 0,
-                                'stdev': 0,
-                                'min': 0,
-                                }
-            if processingTime['distributionType'] == 'Normal' and\
-                  processingTime.get('max', None) is None:
-                processingTime['max'] = float(processingTime['mean']) + 5 * float(processingTime['stdev'])
+        if not processingTime:
+            processingTime = {'Fixed':{'mean': 0 }}
+        if 'Normal' in processingTime.keys() and\
+                processingTime['Normal'].get('max', None) is None:
+            processingTime['Normal']['max'] = float(processingTime['Normal']['mean']) + 5 * float(processingTime['Normal']['stdev'])
     
-            CoreObject.__init__(self, id, name)
-            self.rng=RandomNumberGenerator(self, **processingTime)
-            
-             # ============================== variable that is used for the loading of machines =============
-            self.exitAssignedToReceiver = False             # by default the objects are not blocked 
-                                                            # when the entities have to be loaded to operatedMachines
-                                                            # then the giverObjects have to be blocked for the time
-                                                            # that the machine is being loaded 
-            from Globals import G
-            G.AssemblyList.append(self)
+        CoreObject.__init__(self, id, name)
+        self.rng=RandomNumberGenerator(self, processingTime)
+        
+         # ============================== variable that is used for the loading of machines =============
+        self.exitAssignedToReceiver = False             # by default the objects are not blocked 
+                                                        # when the entities have to be loaded to operatedMachines
+                                                        # then the giverObjects have to be blocked for the time
+                                                        # that the machine is being loaded 
+        from Globals import G
+        G.AssemblyList.append(self)
 
     # =======================================================================
     # parses inputs if they are given in a dictionary

dream/simulation/BatchDecomposition.py

@@ -50,18 +50,17 @@ class BatchDecomposition(CoreObject):
         self.type="BatchDecomposition"              #String that shows the type of object
 
         if not processingTime:
-          processingTime = { 'distributionType': 'Fixed',
-                             'mean': 1, }
-        if processingTime['distributionType'] == 'Normal' and\
-              processingTime.get('max', None) is None:
-          processingTime['max'] = float(processingTime['mean']) + 5 * float(processingTime['stdev'])
+            processingTime = {'Fixed':{'mean': 0 }}
+        if 'Normal' in processingTime.keys() and\
+                processingTime['Normal'].get('max', None) is None:
+            processingTime['Normal']['max'] = float(processingTime['Normal']['mean']) + 5 * float(processingTime['Normal']['stdev'])
         
         # holds the capacity of the object 
         self.numberOfSubBatches=int(numberOfSubBatches)
         # sets the operator resource of the Machine
         self.operator=operator         
         # Sets the attributes of the processing (and failure) time(s)
-        self.rng=RandomNumberGenerator(self, **processingTime)
+        self.rng=RandomNumberGenerator(self, processingTime)
         from Globals import G
         G.BatchDecompositionList.append(self)
 

dream/simulation/BatchReassembly.py

@@ -49,18 +49,17 @@ class BatchReassembly(CoreObject):
         CoreObject.__init__(self,id, name)
         self.type="BatchRassembly"              #String that shows the type of object
         if not processingTime:
-          processingTime = { 'distributionType': 'Fixed',
-                             'mean': 1, }
-        if processingTime['distributionType'] == 'Normal' and\
-              processingTime.get('max', None) is None:
-          processingTime['max'] = float(processingTime['mean']) + 5 * float(processingTime['stdev'])
+            processingTime = {'Fixed':{'mean': 0 }}
+        if 'Normal' in processingTime.keys() and\
+                processingTime['Normal'].get('max', None) is None:
+            processingTime['Normal']['max'] = float(processingTime['Normal']['mean']) + 5 * float(processingTime['Normal']['stdev'])
           
         # holds the capacity of the object 
         self.numberOfSubBatches=numberOfSubBatches
         # sets the operator resource of the Machine
         self.operator=operator         
         # Sets the attributes of the processing (and failure) time(s)
-        self.rng=RandomNumberGenerator(self, **processingTime)
+        self.rng=RandomNumberGenerator(self, processingTime)
         from Globals import G
         G.BatchReassemblyList.append(self)
         # flag to show if the objects outputs results

dream/simulation/BatchSource.py

@@ -31,10 +31,10 @@ import simpy
 from RandomNumberGenerator import RandomNumberGenerator
 
 class BatchSource(Source):
-    def __init__(self, id, name, interarrivalTime=None,
+    def __init__(self, id, name, interArrivalTime=None,
                  entity='Dream.Batch', batchNumberOfUnits=1, **kw):
         Source.__init__(self, id=id, name=name,
-                        interarrivalTime=interarrivalTime, entity=entity)
+                        interArrivalTime=interArrivalTime, entity=entity)
         self.numberOfUnits = int(batchNumberOfUnits)
         from Globals import G
         G.BatchSourceList.append(self)  

dream/simulation/Dismantle.py

@@ -67,16 +67,12 @@ class Dismantle(CoreObject):
         CoreObject.__init__(self, id, name)
         from Globals import G
         if not processingTime:
-            processingTime = {'distributionType': 'Fixed',
-                            'mean': 0,
-                            'stdev': 0,
-                            'min': 0,
-                            }
-        if processingTime['distributionType'] == 'Normal' and\
-              processingTime.get('max', None) is None:
-            processingTime['max'] = float(processingTime['mean']) + 5 * float(processingTime['stdev'])
+            processingTime = {'Fixed':{'mean': 0 }}
+        if 'Normal' in processingTime.keys() and\
+                processingTime['Normal'].get('max', None) is None:
+            processingTime['Normal']['max'] = float(processingTime['Normal']['mean']) + 5 * float(processingTime['Normal']['stdev'])
 
-        self.rng=RandomNumberGenerator(self, **processingTime)   
+        self.rng=RandomNumberGenerator(self, processingTime)   
                                     
     #===========================================================================
     # the initialize method