start using ** attr

dream/simulation/Assembly.py

@@ -78,6 +78,8 @@ class Assembly(CoreObject):
                                                             # 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/CoreObject.py

@@ -34,7 +34,7 @@ import simpy
 class CoreObject(object):
     class_name = 'Dream.CoreObject'
     
-    def __init__(self, id='', name='', inputsDict={}, **kw):
+    def __init__(self, id, name, inputsDict={}, **kw):
         self.id = id
         self.objName = name
         #     lists that hold the previous and next objects in the flow
@@ -68,15 +68,6 @@ class CoreObject(object):
         self.station_col_inds=[]
         self.op_col_indx=None
         # if there is input in a dictionary parse from it
-        if inputsDict:
-            self.parseInputs(inputsDict)
-            
-    # =======================================================================
-    # parses inputs if they are given in a dictionary
-    # =======================================================================       
-    def parseInputs(self, inputsDict):
-        self.id = inputsDict.get('id')
-        self.objName = inputsDict.get('name')
         from Globals import G
         G.ObjList.append(self)  # add object to ObjList
                 

dream/simulation/Exit.py

@@ -45,16 +45,7 @@ class Exit(CoreObject):
         self.Lifespan=[] 
         self.TaktTime=[]   
         # if input is given in a dictionary
-        if inputsDict:
-            CoreObject.__init__(self, inputsDict=inputsDict)
-        else:
         CoreObject.__init__(self, id, name) 
-            
-    # =======================================================================
-    # parses inputs if they are given in a dictionary
-    # =======================================================================       
-    def parseInputs(self, inputsDict):
-        CoreObject.parseInputs(self, inputsDict)
         from Globals import G
         G.ExitList.append(self)           
                    

dream/simulation/LineGenerationJSON.py

@@ -278,12 +278,6 @@ def createObjects():
           element.pop(k, None)
         objClass = element.pop('_class')
 
-        if objClass=='Dream.Source':
-            S=Source(**element)
-            S.nextIds=getSuccessorList(element['id'])
-            G.SourceList.append(S)
-            G.ObjList.append(S)
-
         if objClass=='Dream.BatchSource':
             S = BatchSource(**element)
             S.nextIds=getSuccessorList(element['id'])
@@ -294,14 +288,21 @@ def createObjects():
         elif objClass in ['Dream.Machine', 'Dream.BatchScrapMachine', 'Dream.M3', 'Dream.MachineJobShop',
                           'Dream.MachineManagedJob', 'Dream.MouldAssembly', 'Dream.Exit', 'Dream.ExitJobShop', 
                           'Dream.Queue', 'Dream.RoutingQueue', 'Dream.QueueJobShop', 'Dream.QueueManagedJob',
-                          'Dream.Assembly', 'Dream.Dismantle']:
+                          'Dream.Assembly', 'Dream.Dismantle', 'Dream.Source']:
+            inputDict=dict(element)
+            if 'wip' in inputDict:
+                del inputDict['wip']
+            if 'failures' in inputDict:
+                del inputDict['failures']
+            if 'shift' in inputDict:
+                del inputDict['shift']
             objectType=Globals.getClassFromName(objClass)
-            coreObject=objectType(inputsDict=element)
+            coreObject=objectType(**inputDict)
             # get the successorList for the 'Parts'
             coreObject.nextPartIds=getSuccessorList(element['id'], lambda source, destination, edge_data: edge_data.get('entity') == 'Part')
             # get the successorList for the 'Frames'
             coreObject.nextFrameIds=getSuccessorList(element['id'], lambda source, destination, edge_data: edge_data.get('entity') == 'Frame')
-            coreObject.nextIds=getSuccessorList(element['id'])           # update the nextIDs list of the machine
+            coreObject.nextIds=getSuccessorList(element['id'])           # update the nextIDs list of the object
                                                                                                                             
         elif objClass=='Dream.Conveyer':
             id=element.get('id', 'not found')

dream/simulation/Machine.py

@@ -49,18 +49,13 @@ class Machine(CoreObject):
     # =======================================================================
     # initialise the id the capacity, of the resource and the distribution
     # =======================================================================
-    def __init__(self, id='', name='', capacity=1, processingTime=None,
-                  failureDistribution='No', MTTF=0, MTTR=0, availability=0, repairman='None',\
+    def __init__(self, id, name, capacity=1, processingTime=None,
+                  repairman='None',\
                   operatorPool='None',operationType='None',\
                   setupTime=None, loadTime=None,
                   isPreemptive=False, resetOnPreemption=False,
                   canDeliverOnInterruption=False, inputsDict={}, failures=None):
         self.type="Machine"                         #String that shows the type of object
-        # if input is given in a dictionary
-        if inputsDict:
-            CoreObject.__init__(self, inputsDict=inputsDict)
-        # else read the separate ones
-        else:
         CoreObject.__init__(self, id, name)
         if not processingTime:
           processingTime = { 'distributionType': 'Fixed',
@@ -85,15 +80,10 @@ class Machine(CoreObject):
  
         #     holds the capacity of the machine 
         self.capacity=capacity
-            #     define the distribution types of the processing and failure times respectively
-            self.failureDistType=failureDistribution    #the distribution that the failure follows   
         #     sets the repairman resource of the Machine
         self.repairman=repairman
         #     Sets the attributes of the processing (and failure) time(s)
         self.rng=RandomNumberGenerator(self, **processingTime)
-            self.MTTF=MTTF
-            self.MTTR=MTTR
-            self.availability=availability
         # check whether the operators are provided with a skills set
         self.dedicatedOperator=self.checkForDedicatedOperators()
         # create an operatorPool if needed
@@ -128,106 +118,16 @@ class Machine(CoreObject):
         self.assignedOperator=True
         # flag notifying the the station can deliver entities that ended their processing while interrupted
         self.canDeliverOnInterruption=canDeliverOnInterruption
-
-    # =======================================================================
-    # parses inputs if they are given in a dictionary
-    # =======================================================================       
-    def parseInputs(self, inputsDict):
-        CoreObject.parseInputs(self, inputsDict)
         from Globals import G
-        processingTime=inputsDict.get('processingTime',{})
-        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'])
-
-        setupTime=inputsDict.get('setupTime',{})
-        if not setupTime:
-          setupTime = { 'distributionType': 'Fixed',
-                        'mean': 1, }
-        if setupTime['distributionType'] == 'Normal' and\
-              setupTime.get('max', None) is None:
-          setupTime['max'] = float(setupTime['mean']) + 5 * float(setupTime['stdev'])
-
-        loadTime=inputsDict.get('loadTime',{})
-        if not loadTime:
-          loadTime = { 'distributionType': 'Fixed',
-                        'mean': 1, }
-        if loadTime['distributionType'] == 'Normal' and\
-              loadTime.get('max', None) is None:
-          loadTime['max'] = float(loadTime['mean']) + 5 * float(loadTime['stdev'])
-
-        #     holds the capacity of the machine 
-        self.capacity=inputsDict.get('capacity',1)
-        #     define the distribution types of the processing and failure times respectively
-        self.rng=RandomNumberGenerator(self, **processingTime)
-        # check whether the operators are provided with a skills set
-        self.dedicatedOperator=self.checkForDedicatedOperators()
-        if len(G.OperatorPoolsList)>0:
-            for operatorPool in G.OperatorPoolsList:                    # find the operatorPool assigned to the machine
-                if(self.id in operatorPool.coreObjectIds):                   # and add it to the machine's operatorPool
-                    machineOperatorPoolList=operatorPool                # there must only one operator pool assigned to the machine,
-                                                                        # otherwise only one of them will be taken into account
-                else:
-                    machineOperatorPoolList=[]                          # if there is no operatorPool assigned to the machine
-        else:                                                           # then machineOperatorPoolList/operatorPool is a list
-            machineOperatorPoolList=[]                                  # if there are no operatorsPool created then the 
-                                                                        # then machineOperatorPoolList/operatorPool is a list
-        if (type(machineOperatorPoolList) is list):                 # if the machineOperatorPoolList is a list
-                                                                    # find the operators assigned to it and add them to the list
-            for operator in G.OperatorsList:                        # check which operator in the G.OperatorsList
-                if(self.id in operator.coreObjectIds):                   # (if any) is assigned to operate
-                    machineOperatorPoolList.append(operator)        # the machine with ID equal to id
-        
-        self.operatorPool=machineOperatorPoolList
-        # create an operatorPool if needed
-        self.createOperatorPool(self.operatorPool)
-        # holds the Operator currently processing the Machine
-        self.currentOperator=None
-        # define if load/setup/removal/processing are performed by the operator 
-        self.operationType=inputsDict.get('operationType', 'None')
-        # boolean to check whether the machine is being operated
-        self.toBeOperated = False
-        # define the load times
-        self.loadRng = RandomNumberGenerator(self, **loadTime)
-        # variable that informs on the need for setup
-        self.setUp=True
-        # define the setup times
-        self.stpRng = RandomNumberGenerator(self, **setupTime)
-        # examine if there are multiple operation types performed by the operator
-        #     there can be Setup/Processing operationType
-        #     or the combination of both (MT-Load-Setup-Processing) 
-        self.multOperationTypeList=[]   
-        if self.operationType.startswith("MT"):
-            OTlist = self.operationType.split('-')
-            self.operationType=OTlist.pop(0)
-            self.multOperationTypeList = OTlist
-        else:
-            self.multOperationTypeList.append(self.operationType)
-
-        # flags used for preemption purposes
-        preemption=inputsDict.get('preemption',{})
-        self.isPreemptive=False
-        self.resetOnPreemption=False
-        if len(preemption)>0:
-            self.isPreemptive=bool(int(preemption.get('isPreemptive') or 0))
-            self.resetOnPreemption=bool(int(preemption.get('resetOnPreemption', 0)))
-        # flag notifying that there is operator assigned to the actievObject
-        self.assignedOperator=True
-        # flag notifying the the station can deliver entities that ended their processing while interrupted
-        self.canDeliverOnInterruption=bool(inputsDict.get('canDeliverOnInterruption') or 0)     
-
         self.repairman='None'
         for repairman in G.RepairmanList:                   # check which repairman in the G.RepairmanList
             if(self.id in repairman.coreObjectIds):              # (if any) is assigned to repair 
                 self.repairman=repairman                                 # the machine with ID equal to id
-
         G.MachineList.append(self)                             # add machine to global MachineList
         if self.operatorPool!="None":
             G.OperatedMachineList.append(self)                 # add the machine to the operatedMachines List
 
+   
     # =======================================================================
     # initialize the machine
     # =======================================================================        

dream/simulation/Queue.py

@@ -39,9 +39,6 @@ class Queue(CoreObject):
     #===========================================================================
     def __init__(self, id='', name='', capacity=1, isDummy=False, schedulingRule="FIFO", level=None, gatherWipStat=False, inputsDict={}):
         self.type="Queue"           # String that shows the type of object
-        if inputsDict:
-            CoreObject.__init__(self,inputsDict=inputsDict)
-        else:
         CoreObject.__init__(self, id, name)
         # used for the routing of the entities
         #     holds the capacity of the Queue
@@ -52,7 +49,7 @@ class Queue(CoreObject):
 
         #     No failures are considered for the Queue        
 
-            self.isDummy=isDummy                    #Boolean that shows if it is the dummy first Queue
+        self.isDummy=bool(int(isDummy))                    #Boolean that shows if it is the dummy first Queue
         self.schedulingRule=schedulingRule      #the scheduling rule that the Queue follows
         self.multipleCriterionList=[]           #list with the criteria used to sort the Entities in the Queue
         SRlist = [schedulingRule]
@@ -73,43 +70,8 @@ class Queue(CoreObject):
         if level:
             assert level<=self.capacity, "the level cannot be bigger than the capacity of the queue"
         self.level=level
-            
-    # =======================================================================
-    # parses inputs if they are given in a dictionary
-    # =======================================================================       
-    def parseInputs(self, inputsDict):
-        CoreObject.parseInputs(self, inputsDict)
         from Globals import G
         G.QueueList.append(self)
-        # holds the capacity of the Queue
-        capacity=int(inputsDict.get('capacity') or 1)
-        if capacity>0:
-            self.capacity=capacity
-        else:
-            self.capacity=float("inf")
-
-        self.isDummy=bool(int(inputsDict.get('isDummy') or 0))                    #Boolean that shows if it is the dummy first Queue
-        self.schedulingRule=inputsDict.get('schedulingRule', 'FIFO')                                        #the scheduling rule that the Queue follows
-        self.multipleCriterionList=[]           #list with the criteria used to sort the Entities in the Queue
-        SRlist = [self.schedulingRule]
-        if self.schedulingRule.startswith("MC"):     # if the first criterion is MC aka multiple criteria
-            SRlist = self.schedulingRule.split("-")  # split the string of the criteria (delimiter -)
-            self.schedulingRule=SRlist.pop(0)   # take the first criterion of the list
-            self.multipleCriterionList=SRlist   # hold the criteria list in the property multipleCriterionList
- 
-        for scheduling_rule in SRlist:
-          if scheduling_rule not in self.getSupportedSchedulingRules():
-            raise ValueError("Unknown scheduling rule %s for %s" %
-              (scheduling_rule, id))
-
-        self.gatherWipStat=bool(int(inputsDict.get('gatherWipStat', 0)))
-        # Will be populated by an event generator
-        self.wip_stat_list = []
-        level=int(inputsDict.get('level') or 1)
-        # trigger level for the reallocation of operators
-        if level:
-            assert level<=self.capacity, "the level cannot be bigger than the capacity of the queue"
-        self.level=level
             
     @staticmethod
     def getSupportedSchedulingRules():

dream/simulation/Source.py

@@ -98,6 +98,8 @@ class Source(CoreObject):
         self.item=Globals.getClassFromName(entity)      #the type of object that the Source will generate
                
         self.scheduledEntities=[]       # list of creations that are scheduled. pattern is [timeOfCreation, EntityCounter]     
+        from Globals import G
+        G.SourceList.append(self)  
     
     #===========================================================================
     # The initialize method of the Source class