def SetRequiredTokens(self, requiredTokenByStateName, stateTokenSpec):
if len(stateTokenSpec) != 3:
utils.log("Bad token spec for " + requiredTokenByStateName + " " + repr(stateTokenSpec))
stateName = stateTokenSpec[0]
properties = stateTokenSpec[2]
requiredTokens = stateTokenSpec[1]
requiredTokenByStateName[stateName] = [requiredTokens, properties]
def run(self):
super(Lims, self).runSimulate()
# Do the work
# post processing
properties = {}
tokens = self.getTokenList().getTokensByOwnerAndSpec("ap", self, properties, lockedState=True)
if tokens == None or len(tokens) == 0:
utils.logTrace("No Assay Plate barcode")
tokenApInProcess = tokens[0]
barcodeAP = tokenApInProcess.getProperty("barcodeAP")
properties = {}
tokens = self.getTokenList().getTokensByOwnerAndSpec("sp", None, properties, lockedState=False)
numreq = 3
for token in tokens:
color = token.getProperty("color")
if color == "free":
token.setProperty("barcodeAP", barcodeAP)
token.setProperty("prevTransition", "lims")
token.setProperty("color", "reserved")
numreq -= 1
if numreq <= 0:
break
# Complete transition
super(Lims, self).complete()
utils.log("Exit " + self.getName() + " " + repr(os.getpid()) + " " + threading.currentThread().getName())
exit()
def run(self):
super(Dispenser, self).runSimulate()
# post process
properties = {}
tokens = self.getTokenList().getTokensByOwnerAndSpec("ap", self, properties, lockedState=True)
tokenAP = tokens[0]
properties = {"barcodeAP": tokenAP.getProperty("barcodeAP")}
tokens = self.getTokenList().getTokensByOwnerAndSpec("sp", self, properties, lockedState=True)
if len(tokens) == 0:
utils.log("Cannot find allocated sp token in Dispenser")
# For debugging
tokens = self.getTokenList().getTokensByOwnerAndSpec("sp", self, properties, lockedState=True)
tokenCompleted = tokens[0]
tokenCompleted.removeProperty("barcodeAP")
tokenCompleted.removeProperty("color")
# Get remaining reserved but not allocated source plates before completing transition and adding locked sp
tokens = self.getTokenList().getTokensByOwnerAndSpec("sp", None, properties, lockedState=False)
# Complete transition
# CAREFUL - Attempts to override the petri model by changing the color of a token must be done after completeTransitionItemObject
complete = False
if len(tokens) == 0:
complete = True
self.getTransitionMaster().completeTransitionItemObject(self)
if complete:
tokenAP.setProperty("color", "complete")
utils.log("Exit " + self.getName() + " " + repr(os.getpid()) + " " + threading.currentThread().getName())
exit()
return True
def setProperty(self, prop, value):
if prop == None or value == None:
utils.logTrace("Attempt to set illegal property " + repr(prop) + " value: " + repr(value))
if prop in self.properties:
old = ""
if self.properties[prop] != None:
old = self.properties[prop]
utils.log("Replacing " + prop + " old value: " + old + " new value " + value)
self.properties[prop] = value
def Fire(self, tokenList, reqPropertyValues={}):
try:
self.tmLock.acquire()
self.dumpActiveThreads()
transitionItemObject = TransitionItemFactory.getObject(self.transitionName, self)
transitionItemObject.setTransitionMaster(self)
transitionItemObject.setTokenList(self.getPetriNet().getTokenList())
utils.log("Firing " + transitionItemObject.getName() + " ID: " + transitionItemObject.getId())
self.launchTransitionItemObject(transitionItemObject, reqPropertyValues)
finally:
self.tmLock.release()
def dumpActiveThreads(self):
l = ""
main_thread = threading.currentThread()
for t in threading.enumerate():
if t is main_thread or not t.getName().startswith("trans_"):
continue
l += t.getName() + "(" + t.getRemainStr() + ") "
if t.isAlive():
l += "Active"
else:
l += "Dead"
l += "\n"
utils.log("Threads:\n" + l + "\n")
def cycleResult(self):
if self.stepsRemain <= 0:
return 0
randomComplete = randrange(10)
randomComplete = 8
if randomComplete <= 2:
self.errorCode = randomComplete
return -1
if randomComplete >= 7:
self.stepsRemain -= 1
utils.log(self.getName() + " completed a step " + self.getRemainStr())
if self.stepsRemain <= 0:
return 0
return self.stepsRemain
def completeTransitionItemObject(self, transitionItemObject):
try:
utils.log("Completing " + transitionItemObject.getName())
self.tmLock.acquire()
if transitionItemObject.getErrorCode() != 0:
utils.log(
"Transition "
+ transitionItemObject.getName()
+ " failed with code "
+ str(transitionItemObject.getErrorCode())
)
transitionItemObject.getTokenList().unlockAllByTransitionObject(transitionItemObject)
else:
acquired = self.petriNet.getTokenList().getTokensByOwnerAndSpec(
None, transitionItemObject, properties={}, lockedState=True
)
self.adjustTokens(transitionItemObject, acquired, self.deliveredTokensByState)
properties = {}
tokens = self.petriNet.getTokenList().getTokensByOwnerAndSpec(
None, transitionItemObject, properties, lockedState=True
)
for token in tokens:
token.unlock()
if not transitionItemObject in transitionItemObject.getTransitionMaster().transitionItemsRunning:
utils.log(
"Attempt to delete transition item that is not in the run queue " + transitionItemObject.getName()
)
ndx = transitionItemObject.getTransitionMaster().transitionItemsRunning.index(transitionItemObject)
del transitionItemObject.getTransitionMaster().transitionItemsRunning[ndx]
self.removeActiveThread(transitionItemObject)
utils.log(
"Tokens after completion of "
+ transitionItemObject.getName()
+ " "
+ self.petriNet.PrintTokenList(self.transitionName)
)
msg = tokenList.dump(
"-------Completion "
+ transitionItemObject.getName()
+ " ID: "
+ transitionItemObject.getId()
+ " Active Transitions "
+ str(self.petriNet.getTotalActive())
)
utils.log(msg, "trace_" + str(utils.sessionID) + ".txt")
finally:
self.tmLock.release()
def launchTransitionItemObject(self, transitionItemObject, reqPropertyValues={}):
try:
utils.log("Launching " + transitionItemObject.getName())
msg = tokenList.dump(
"-------Before Launch "
+ transitionItemObject.getName()
+ " ID: "
+ transitionItemObject.getId()
+ " Active Transitions "
+ str(self.petriNet.getTotalActive())
)
utils.log(msg, "trace_" + str(utils.sessionID) + ".txt")
for stateName in self.requiredTokensByState.keys():
tokenSpec = self.requiredTokensByState[stateName]
numLocked = transitionItemObject.getTokenList().lock(
stateName, tokenSpec, transitionItemObject, reqPropertyValues
)
if tokenSpec[1] != numLocked:
utils.logTrace("Could not lock sufficient tokens for " + stateName)
transitionItemObject.getTransitionMaster().transitionItemsRunning.append(transitionItemObject)
self.addActiveThread(transitionItemObject)
utils.log(
"Tokens after launch of "
+ transitionItemObject.getName()
+ " "
+ self.petriNet.PrintTokenList(self.transitionName)
)
msg = tokenList.dump(
"-------Running "
+ transitionItemObject.getName()
+ " ID: "
+ transitionItemObject.getId()
+ " Active Transitions "
+ str(self.petriNet.getTotalActive())
)
utils.log(msg, "trace_" + str(utils.sessionID) + ".txt")
# Run the transition as independently as possible
transitionItemObject.runTopLevel()
finally:
pass
def RunSimulation(self, iterations, tokenList, assayPlates=[]):
# Initialize
self.PrintHeader() # prints e.g. "H, O, H2O"
self.tokenList = tokenList
if assayPlates != None:
dosingNet = DosingNet(self.tokenList, assayPlates)
self.store = dosingNet
utils.log(self.PrintTokenList("Initial")) # prints e.g. "3, 5, 2"
# Run the engine
idle = 0
for i in range(iterations):
self.round = i
utils.log("--- Round " + str(i))
runnableTransitionData = self.getRunnableTransitionData()
self.idle()
if len(runnableTransitionData) == 0:
if idle > 3:
utils.log("Nothing to do")
idle += 1
# time.sleep(1)
continue
idle = 0
transitionName = self.FireOneRule(runnableTransitionData)
utils.log("--- Completed " + transitionName + " round " + str(i) + " iterations")
def PrintHeader(self):
a = "<State: unlocked(total, locked),>*, Transition"
utils.log(a)
def run(self):
utils.log("Entry " + self.getName() + ".run " + repr(os.getpid()) + " " + threading.currentThread().getName())
while self.getRemain() > 0:
# time.sleep(2)
if self.cycleResult() <= 0:
self.getTransitionMaster().completeTransitionItemObject(self)
def runSimulate(self):
utils.log("Entry " + self.getName() + ".run " + repr(os.getpid()) + " " + threading.currentThread().getName())
while self.getRemain() > 0:
# time.sleep(2)
if self.cycleResult() <= 0:
return
def IsEnabled(self, tokenList):
# First get common properties across required tokens
commonValuesByTokenName = {}
for transitionProperty in self.properties.keys():
commonValuesByTokenName[transitionProperty] = {}
for reqTokenName, tokenSpec in self.requiredTokensByState.items():
tokensAvailable = 0
numRequired = tokenSpec[1]
if reqTokenName in tokenList.list:
tokens = tokenList.getTokensByOwnerAndSpec(
reqTokenName, transitionOwnerObject=None, properties=tokenSpec[0], lockedState=False
)
for token in tokens:
tokensAvailable += 1
for transitionPropertyName in self.properties.keys():
if transitionPropertyName in token.getProperties():
if not token.getName() in commonValuesByTokenName[transitionPropertyName]:
commonValuesByTokenName[transitionPropertyName][token.getName()] = []
commonValuesByTokenName[transitionPropertyName][token.getName()].append(
token.getProperty(transitionPropertyName)
)
if tokensAvailable < numRequired:
utils.log("Cannot run " + self.getName() + " because not enough " + reqTokenName + "'s available.'")
return False, {}
else:
utils.log("Cannot run " + self.getName() + " because token " + reqTokenName + " not available.")
return False, {}
# So commonValuesByTokenName is owned by the transitionItem and manages the properties that it cares about.
# For each one of these properties, it contains a list of all of its required tokens and the values of that property
# across those tokens. The idea is that the transition can specify that for a given property if the tokens available
# contain that property then their values must match. For example, if the "dosing" transition requires an "assay plate"
# and a "source plate" token then it may require that the common assay plate barcode be the same in both tokens for
# those tokens to be acquired by the instance of the transition.
intersections = {}
intersect = []
for transitionPropertyName in commonValuesByTokenName.keys():
prev = []
req = ["any"]
if transitionPropertyName in self.properties and self.properties[transitionPropertyName] != None:
req = self.properties[transitionPropertyName]
if transitionPropertyName == "prevTransition" and "prevTransition" in self.properties:
prev = prev + self.properties["prevTransition"]
if "any" in req:
intersections[transitionPropertyName] = intersect
for tokenName in commonValuesByTokenName[transitionPropertyName].keys():
current = commonValuesByTokenName[transitionPropertyName][tokenName]
if len(prev) > 0 and len(current) > 0:
intersect = [val for val in prev if val in current]
if len(intersect) == 0:
utils.log(
"Cannot run "
+ self.getName()
+ " because no matching on "
+ transitionPropertyName
+ " for "
+ tokenName
)
return False, {}
prev = intersect
else:
prev = current
intersect = current
intersections[transitionPropertyName] = intersect
for tokenName in intersections.keys():
valueList = intersections[tokenName]
# We may have found more than one set of common property values. Choose one set only.
intersections[tokenName] = [valueList[0]] # Choose single member of overlap
utils.log("Candidate " + self.getName() + " intersection " + repr(intersections))
return True, intersections
def runTopLevel(self):
utils.log("Entry TransitionItem.runTopLevel " + threading.currentThread().getName())
self.start()
utils.log("Exit TransitionItem.runTopLevel " + threading.currentThread().getName())
def SelectRandom(self, items):
utils.log("Selecting from " + repr(items.keys()))
randomIndex = randrange(len(items.keys()))
transitionName = items.keys()[randomIndex]
return transitionName, items[transitionName]
if False:
specs = (
("production", [], [["Healthy", 1]], {}),
("deathH", [["Healthy", 1]], [], {}),
("deathI", [["Infected", 1]], [], {}),
("deathV", [["Virion", 1]], [], {}),
("infection", [["Healthy", 1], ["Virion", 1]], [["Infected", 1]], {}),
("production", [["Infected", 1]], [["Infected", 1], ["Virion", 1]], {}),
)
initialTokenAssignments = {"Healthy": 50, "Infected": 3, "Virion": 3}
petriNet = PetriNet(specs)
tokenList = TokenList(initialTokenAssignments)
msg = petriNet.dump(initialTokenAssignments)
utils.log(msg, "trace_" + str(utils.sessionID) + ".txt")
steps = 90
petriNet.RunSimulation(steps, tokenList, assayPlates)
"""
H, O, H2O, Transition
5, 3, 4, split
7, 4, 3, combine
5, 3, 4, split
7, 4, 3, combine
5, 3, 4, combine
3, 2, 5, combine
1, 1, 6, split
3, 2, 5, combine
1, 1, 6, split
3, 2, 5, combine
