several changes

dream/simulation/CoreObject.py

@@ -69,9 +69,6 @@ class CoreObject(ManPyObject):
         # attributes/indices used for printing the route, hold the cols corresponding to the object (entities route and operators route) 
         self.station_col_inds=[]
         self.op_col_indx=None
-        # if there is input in a dictionary parse from it
-        from Globals import ManPyEnvironment
-        G.ObjList.append(self)  # add object to ObjList
         # list of expected signals of a station (values can be used as flags to inform on which signals is the station currently yielding)
         self.expectedSignals={
                                 "isRequested":0,
@@ -93,8 +90,6 @@ class CoreObject(ManPyObject):
         self.WipStat=[]
                 
     def initialize(self):
-        from Globals import ManPyEnvironment
-        self.env=G.env
         self.Up=True                                    #Boolean that shows if the object is in failure ("Down") or not ("up")
         self.onShift=True
         self.onBreak=False
@@ -618,8 +613,7 @@ class CoreObject(ManPyObject):
     # =======================================================================
     def postProcessing(self, MaxSimtime=None): 
         if MaxSimtime==None:
-            from Globals import ManPyEnvironment
-            MaxSimtime=G.maxSimTime
+            MaxSimtime=self.environment.maxSimTime
         
         activeObject=self.getActiveObject()
         activeObjectQueue=self.getActiveObjectQueue()

dream/simulation/Exit.py

@@ -46,13 +46,12 @@ class Exit(CoreObject):
         self.TaktTime=[]   
         # if input is given in a dictionary
         CoreObject.__init__(self, id, name) 
-        from Globals import ManPyEnvironment
-        G.ExitList.append(self)     
         self.cancelCondition=cancelCondition   
                    
     def initialize(self):
         # using the Process __init__ and not the CoreObject __init__
         CoreObject.initialize(self)
+        self.environment.ExitList.append(self)
         
         # initialize the internal Queue (type Resource) of the Exit 
         self.Res=simpy.Resource(self.env, capacity=float('inf'))         
@@ -153,9 +152,8 @@ class Exit(CoreObject):
     #            actions to be taken after the simulation ends
     # =======================================================================
     def postProcessing(self, MaxSimtime=None):
-        from Globals import ManPyEnvironment
         if MaxSimtime==None:
-            MaxSimtime=G.maxSimTime
+            MaxSimtime=self.environment.maxSimTime
         # hold the numberOfExits of each replication
         self.Exits.append(self.numOfExits)
         self.UnitExits.append(self.totalNumberOfUnitsExited) 
@@ -172,7 +170,6 @@ class Exit(CoreObject):
     #                        outputs results to JSON File
     # =======================================================================
     def outputResultsJSON(self):
-        from Globals import ManPyEnvironment
         json = { '_class': 'Dream.%s' % self.__class__.__name__,
                   'id': self.id,
                   'family': self.family,
@@ -182,4 +179,4 @@ class Exit(CoreObject):
         json['results']['takt_time'] = self.TaktTime
         if self.Exits!=self.UnitExits:      #output this only if there was variability in units
             json['results']['unitsThroughput'] = self.UnitExits
-        G.outputJSON['elementList'].append(json)
+        self.environment.outputJSON['elementList'].append(json)

dream/simulation/Globals.py

@@ -117,6 +117,7 @@ class ManPyEnvironment(object):
         self.env=simpy.Environment()
     
         self.totalPulpTime=0     # temporary to track how much time PuLP needs to run 
+        self.SimPyEnvironment=simpy.Environment() 
     
 # =======================================================================
 # method to move entities exceeding a certain safety stock

dream/simulation/LineGenerationJSON.py

@@ -219,7 +219,9 @@ def createObjectResourcesAndCoreObjects(environment,json_data):
             inputDict=dict(element)           
             # create the CoreObject
             coreObject=objectType(**inputDict)
+            coreObject.environment=environment
             coreObject.env=environment.SimPyEnvironment
+            environment.ObjList.append(coreObject)
             # update the nextIDs list of the object
             coreObject.nextIds=getSuccessorList(element['id'])           
             # (Below is only for Dismantle for now)

dream/simulation/ManPyObject.py

@@ -101,14 +101,14 @@ class ManPyObject(object):
         return any(operator.skillsList for operator in G.OperatorsList)
     
     @staticmethod
-    def printTrace(entity='', **kw):
+    def printTrace(environment,entity='', **kw):
         assert len(kw)==1, 'only one phrase per printTrace supported for the moment'
         from Globals import ManPyEnvironment
         import Globals
-        time=G.env.now
+        time=environment.env.now
         charLimit=60
         remainingChar=charLimit-len(entity)-len(str(time))
-        if(G.console=='Yes'):
+        if(environment.console=='Yes'):
             print time,entity,
             for key in kw:
                 if key not in Globals.getSupportedPrintKwrds():
@@ -127,8 +127,7 @@ class ManPyObject(object):
                         suffix=suffix+'>'
                     print phrase,arg,suffix
                 else:
-                    print phrase,arg
-                    
+                    print phrase,arg                    
     # =======================================================================
     # outputs message to the trace.xls 
     # outputs message to the trace.xls. Format is (Simulation Time | Entity or Frame Name | message)

dream/simulation/PrintRoute.py

@@ -29,7 +29,7 @@ def getEventsList(objectsList=[]):
                         events_list.append(exit_time)
     return events_list
 
-def outputRoute():
+def outputRoute(environment):
     '''            
         prints the routes of the Jobs through the model as a table 
         the horizontal axis represents the different stations of the model 
@@ -54,53 +54,53 @@ def outputRoute():
     
     # xx for each station allocate 2 rows and a 3rd one for operators
     
-    if G.trace=='Yes':
-        if G.JobList:
-            G.routeSheetIndex=G.sheetIndex+1
+    if environment.trace=='Yes':
+        if environment.JobList:
+            environment.routeSheetIndex=environment.sheetIndex+1
             # add one more sheet to the trace file
-            G.routeTraceSheet=G.traceFile.add_sheet('sheet '+str(G.routeSheetIndex)+' route', cell_overwrite_ok=True)
-            number_of_machines=len(G.MachineList)
+            environment.routeTraceSheet=environment.traceFile.add_sheet('sheet '+str(environment.routeSheetIndex)+' route', cell_overwrite_ok=True)
+            number_of_machines=len(environment.MachineList)
             sortMachines()  # sort the machines according to the priority specified in JOB_SHOP_TECHNOLOGY_SEQ
             # get the events list
-            G.events_list=getEventsList(G.JobList+G.OperatorsList)
-            G.events_list.sort(cmp=None, key=None, reverse=False)     # sort the events
-            number_of_events=len(G.events_list)                       # keep the total number of events 
+            environment.events_list=getEventsList(environment.JobList+environment.OperatorsList)
+            environment.events_list.sort(cmp=None, key=None, reverse=False)     # sort the events
+            number_of_events=len(environment.events_list)                       # keep the total number of events 
             # create a table number_of_events X number_of_machines
-            G.routeTraceSheet.write(0,0, 'Time/Machines')
+            environment.routeTraceSheet.write(0,0, 'Time/Machines')
             # write the events in the first column and the machineIDs in the first row
-            for j, event in enumerate(G.events_list):
-                G.routeTraceSheet.write(j+1,0,float(event))
+            for j, event in enumerate(environment.events_list):
+                environment.routeTraceSheet.write(j+1,0,float(event))
             # XXX create 3 times as many columns as the number of machines
-            for j, machine in enumerate(G.MachineList):
+            for j, machine in enumerate(environment.MachineList):
                 machine.station_col_inds=range(j*3+1,j*3+3)
                 machine.op_col_indx=j*3+3
-                G.routeTraceSheet.write_merge(0,0,j*3+1,j*3+3,str(machine.id))
+                environment.routeTraceSheet.write_merge(0,0,j*3+1,j*3+3,str(machine.id))
 
             # sort the jobs according to their name
-            G.JobList.sort(key=lambda x:x.id)
+            environment.JobList.sort(key=lambda x:x.id)
             
-            G.cells_to_write=[]
-            for job in G.JobList:
+            environment.cells_to_write=[]
+            for job in environment.JobList:
                 job.printRoute()
             
             # list of cells to be written
-            G.cells_to_write=[]
+            environment.cells_to_write=[]
             # for every job in the JobList
-            for worker in G.OperatorsList:
+            for worker in environment.OperatorsList:
                 worker.printRoute()
             # reset list of cells to be written
-            del G.cells_to_write[:]
-            del G.events_list[:]
+            del environment.cells_to_write[:]
+            del environment.events_list[:]
             
             # print aliases
             try:
-                sample_job=next(x for x in G.JobList)
+                sample_job=next(x for x in environment.JobList)
                 if sample_job.__class__.__name__ in ORDER_COMPONENT_TYPE_SET:
-                    G.JobList.sort(key=lambda x:x.order.id)
+                    environment.JobList.sort(key=lambda x:x.order.id)
             except:
                 pass
-            for j,job in enumerate(G.JobList):
+            for j,job in enumerate(environment.JobList):
                 if job.schedule:
-                    G.routeTraceSheet.write(number_of_events+2+j, 0, job.id)
-                    G.routeTraceSheet.write(number_of_events+2+j, 1, job.alias)
+                    environment.routeTraceSheet.write(number_of_events+2+j, 0, job.id)
+                    environment.routeTraceSheet.write(number_of_events+2+j, 1, job.alias)
             
\ No newline at end of file

dream/simulation/Queue.py

@@ -66,8 +66,6 @@ class Queue(CoreObject):
         if level:
             assert level<=self.capacity, "the level cannot be bigger than the capacity of the queue"
         self.level=level
-        from Globals import ManPyEnvironment
-        G.QueueList.append(self)
             
     @staticmethod
     def getSupportedSchedulingRules():
@@ -80,6 +78,7 @@ class Queue(CoreObject):
     def initialize(self):
         # using the Process __init__ and not the CoreObject __init__
         CoreObject.initialize(self)
+        self.environment.QueueList.append(self)
         # initialise the internal Queue (type Resource) of the Queue object 
         self.Res=simpy.Resource(self.env, self.capacity)
         # event used by router
@@ -99,7 +98,7 @@ class Queue(CoreObject):
         # check if there is WIP and signal receiver
         self.initialSignalReceiver()
         while 1:
-            self.printTrace(self.id, waitEvent='')
+            self.printTrace(self.environment,self.id, waitEvent='')
             # wait until the Queue can accept an entity and one predecessor requests it
             self.expectedSignals['canDispose']=1
             self.expectedSignals['isRequested']=1
@@ -322,11 +321,10 @@ class Queue(CoreObject):
             assert False, "Unknown scheduling criterion %r" % (criterion, )
 
     def outputResultsJSON(self):
-        from Globals import ManPyEnvironment
         json = {'_class': 'Dream.%s' % self.__class__.__name__,
                 'id': str(self.id), 
                 'family': self.family,
                 'results': {} }
         if self.gatherWipStat:
             json['results']['wip_stat_list']=self.WipStat
-        G.outputJSON['elementList'].append(json)
+        self.environment.outputJSON['elementList'].append(json)

dream/simulation/Source.py

@@ -42,9 +42,9 @@ class EntityGenerator(object):
     # the __init__ method of the EntityGenerator
     #===========================================================================
     def __init__(self, victim=None):
-        self.env=G.env
         self.type="EntityGenerator"                       #String that shows the type of object
         self.victim=victim
+        self.env=victim.environment.SimPyEnvironment
             
     #===========================================================================
     # the generator of the EntitiesGenerator
@@ -101,7 +101,6 @@ class Source(CoreObject):
                
         self.scheduledEntities=[]       # list of creations that are scheduled. pattern is [timeOfCreation, EntityCounter]     
         from Globals import ManPyEnvironment
-        G.SourceList.append(self)  
     
     #===========================================================================
     # The initialize method of the Source class
@@ -109,6 +108,7 @@ class Source(CoreObject):
     def initialize(self):
         # using the Process __init__ and not the CoreObject __init__
         CoreObject.initialize(self)
+        self.environment.SourceList.append(self)
         
         # initialize the internal Queue (type Resource) of the Source 
         # self.Res=Resource(capacity=infinity)