comments clean-up

dream/simulation/CoreObject.py

@@ -649,14 +649,6 @@ class CoreObject(Process):
     #===========================================================================
     def activeQueueIsEmpty(self):
         return len(self.Res.activeQ)==0
-    
-#     # =======================================================================
-#     # checks if the object is ready to receive an Entity
-#     # =======================================================================    
-#     def isReadyToGet(self):
-#         return True     # set to true since this control was not needed until now. 
-#                         # to return canAcceptAndIsRequested() would be more logical, but also computationally expensive
-#         #return self.canAcceptAndIsRequested()
         
     # =======================================================================
     # actions to be carried out when the processing of an Entity ends

dream/simulation/Machine.py

@@ -455,9 +455,6 @@ class Machine(CoreObject):
                     # if while waiting (for a canDispose event) became free as the machines that follows emptied it, then proceed
                     if not self.haveToDispose():
                         break
-            # TODO: in operated Machine, sometimes the giver is not signalled from the removeEntity method because there
-            #       there was no operator available. In this case, by the time the operator is available again the Machine
-            #       must receive the entity from the predecessor and thus the 
     
     # =======================================================================
     # actions to be carried out when the processing of an Entity ends
@@ -475,13 +472,8 @@ class Machine(CoreObject):
             activeObject.outputTrace(activeObject.getActiveObjectQueue()[0].name,"ended processing in "+activeObject.objName)
         except IndexError:
             pass
-        # the entity that just got processed is cold again it will get 
-        # hot again by the time it reaches the giver of the next machine
         # TODO: Not only Machines require time to process entities
         #     entities such as batchReassembly/Decomposition require time to process entities
-        # TODO: We must consider also the case that entities can be blocked before they can reach 
-        #     the heating point. In such a case they must be removed from the G.pendingEntities list
-        #     and added again after they are unblocked
         if activeEntity.family=='Entity':
             successorsAreMachines=True
             from Globals import G

dream/simulation/ObjectInterruption.py

@@ -59,26 +59,6 @@ class ObjectInterruption(Process):
     def invoke(self):
         self.isCalled.signal(now())
     
-#     # =======================================================================
-#     #                 return control to the Machine.run
-#     # =======================================================================
-#     def exit(self):
-#         self.call=False
-    
-#     # =======================================================================
-#     #                        call the objectInterruption 
-#     #        filter for object interruption - yield waituntil isCalled
-#     # =======================================================================
-#     def isCalled(self):
-#         return self.call
-    
-#     # =======================================================================
-#     #        the objectIterruption returns control to machine.Run
-#     #        filter for Machine - yield request/release operator
-#     # =======================================================================
-#     def isSet(self):
-#         return not self.call
-    
     #===========================================================================
     # outputs data to "output.xls"
     #===========================================================================
@@ -119,7 +99,6 @@ class ObjectInterruption(Process):
     #===========================================================================
     def reactivateVictim(self):
         self.victim.interruptionEnd.signal(now())
-#         reactivate(self.victim)  
         
     #===========================================================================
     # outputs message to the trace.xls. Format is (Simulation Time | Victim Name | message)