def generateLongNameReport(self,fluxModel):
report = Report()
for name in fluxModel.getMetabolicNetwork().getOrderedReactionNames():
reaction = fluxModel.getMetabolicNetwork().getReaction(name)
longName = reaction.getName()
equation = reaction.getEquation()
report.addElement(name,"LongName",longName)
report.addElement(name,"Equation",equation)
return report
def generateLimitReport(self,limits):
result = Report()
upper = {}
lower = {}
for key in limits.keys():
(lower[key],upper[key]) = limits[key]
result.addReportColumnHash("LowerBound",lower)
result.addReportColumnHash("UpperBound",upper)
return result
def writeAnnotatedTargets(self,objective,model,annotationName,regex,iteration,oPrediction={},nPrediction={},outputFileName=None):
if outputFileName == None:
outputFileName = "Target_Report_T_%s_C_%s_M_%s_N_%s_S_%s_K_%s_I_%s.txt" % (self.resultTag,self.control,self.modelName,self.naturalObjectiveName,self.syntheticObjectiveName,self.con.controlMax,iteration)
aValue = self._annotateObjective(objective, model, annotationName, regex)
controlValues = self._condenseObjective(objective)
controlValues = self._annotateGenes(controlValues, model, annotationName, regex)
controlScores = self._controlScore(objective,oPrediction, nPrediction)
controlScores = self._annotateGenes(controlScores, model, annotationName, regex)
controlScore = self._condenseMap(controlScores,sum)
report = Report()
report.addColumnHash("Control", aValue)
report.addColumnHash("Flux", controlScore)
report.addColumnHash("Reaction Control", controlValues)
report.addColumnHash("Flux Changes", controlScores)
oName = self.resultDirectory + outputFileName
try:
writer = ReportWriter()
writer.setFile(oName)
writer.write(report)
writer.closeFile()
if self.verbose: print "Report written [%s]" % (outputFileName)
except:
if self.verbose: print "Failed to write report [%s] " % (outputFileName)
return None
def scanControlDependencies(con,originalModel,controls,options,searchRange,targetPrecent = 0.80,verbose = False):
report = Report()
controlMaps = []
controlSets = set()
for z in searchRange:
(controlMap,controlSet,iReport) = findControlDependencies(con,originalModel,controls,controlSets,options,z,targetPrecent,verbose)
controlSets = controlSets.union(controlSet)
controlMaps.extend(controlMap)
report.extend(iReport)
return (controlMaps,report)
def loadVariousControlTable(fileNameTag,controls,sObjectiveTags,k,n,filter=lambda x: True):
'''
Parse control table files
'''
keyTag = "Row Names"
controlTag = "Control"
productionTag = ''
#bestTargets = 'accA,fadD,fadE'.split(",")
#bestTargets = 'aceE,fabH,fabD,accA,fabA,fabZ,fabB,fabF,fadA,fadI,fadB,fadD'.split(",")
#mTargets = "pgi,pfkA,eno,fbaA,tpiA,gapA,pgk,gpmA".split(",")
#bestTargets.extend(mTargets)
bestTargets = 'accA,lpdA,aceE,aceF,gapA,pgk,fumB,fumC,mdh,acnA,scpC,sucC,sucD,sdhA,sdhB'.split(",")
#bestTargets = 'lpdA,aceE,aceF,'.split(",")
summaryReport = Report()
targetReport = Report()
print "best targets %s" % (bestTargets)
for sObjective in sObjectiveTags:
controlMaps = loadControlTableRange(fileNameTag, controls, sObjective, k, n, keyTag, controlTag, productionTag,filter)
(uniqueTargets,targetValues,maxTargetSize,(bestMaps,score)) = processControlMaps(controlMaps, minProduction=0.0,bestTargets=bestTargets)
print "Production %s => %s" % (sObjective,score)
for map in bestMaps:
print "%s" % (map)
uTargetSize = len(uniqueTargets)
summaryReport.add(sObjective, "Unique Target Number", uTargetSize)
summaryReport.add(sObjective, "Largest Design", maxTargetSize)
for (key,value) in targetValues.items():
targetReport.add(key, sObjective, value)
return (summaryReport,targetReport)
def generateReport(self,fluxModel, modelName, predictions, limits = False, longName = False,):
result = Report()
if longName:
longNamesReport = self.generateLongNameReport(fluxModel)
result.extend(longNamesReport)
result.addReportColumnHash("FluxPrediction",predictions)
if limits:
limits = fluxModel.getLimits(modelName)
limitReport = self.generateLimitReport(limits)
result.extend(limitReport)
return result
def findControlDependencies(con,originalModel,controls,exclusion,options,searchSize=0,targetPrecent = 0.40,verbose = False,usePersist=False):
name = "".join(originalModel.modelName)
naturalObjectiveName = options.bioObj
syntheticObjectiveName = options.synthObj
controlTag = options.control
persistTag = "Dependency_persist_%s_%s_%s_%s_%s_%s" % (controlTag,name,naturalObjectiveName,syntheticObjectiveName,str(searchSize),str(targetPercent))
delta = 1e-4
iter = 0
iterSave = 100
completed = set()
controlSet = set()
controlMap = []
report = Report()
persistValue = None
if usePersist:
persistValue = loadPersist(persistTag)
if persistValue != None:
print "loading persisted dependency search"
(completed,controlMap,controlSet,report) = persistValue
controlSubSets = combinations(controls,searchSize)
xcontrolSubSets = set(controlSubSets)
xcontrolSubSets = xcontrolSubSets.difference(completed)
print "Control dependency depth [%s] search sets [%s]" % (searchSize,len(xcontrolSubSets))
lo = LPSolver()
sObjective = {syntheticObjectiveName:-1.0}
iPred = lo.run(model= originalModel, objective = sObjective)
synthVal = iPred[syntheticObjectiveName]
targetSVal = synthVal * targetPrecent
#print "Synthetic Target [%s] = %s * %s" % (targetSVal,synthVal,targetPercent)
controlMin = con.controlMin
controlMax = con.controlMax
con.controlMin = 0
con.controlMax = 0
targets = []
gRMap = con.getGeneTargetMap()
for (lib,prefix,target) in controls:
if gRMap != None:
if target in gRMap.keys():
rTargets = gRMap[target]
targets.extend(rTargets)
else:
targets.append(target)
#-----------------------------
# Run optimization
#-----------------------------
iter = 0
for controlSub in xcontrolSubSets:
iter += 1
completed.add(controlSub)
#Analysis of control
(prediction,objective) = simpleTestOpt(con, originalModel, controlSub, naturalObjectiveName,syntheticObjectiveName,verbose=False,naturalCoefficient=-0.5)
#Save results
syntheticFlux = prediction[syntheticObjectiveName]
#if verbose: print "Objective [%s]" % (objective)
#if verbose: print "Flux [%s]" % (prediction)
if syntheticFlux > targetSVal:
controlThresholds = controlThreshold([controlSub], exclusion)
if controlSub in controlThresholds.keys():
if syntheticFlux <= controlThresholds[controlSub] + delta:
#if verbose: print "no improvement"
continue
if verbose: print "Synthetic Production [%s]" % (syntheticFlux)
controlResultMap = originalModel.annotateGenes(objective,annotationName = "bnumber", regex="[a-zA-Z0-9\(\)]+")
controlTag = str(controlResultMap.keys())
controlSV = (controlSub,syntheticFlux)
controlSet.add(controlSV)
controlSV = (controlResultMap,syntheticFlux)
controlMap.append(controlSV)
#if verbose: print "Control Set [%s]" % (controlSub)
if verbose: print "Control Map [%s]" % (controlResultMap)
report.add(controlTag, "control values", controlResultMap)
report.add(controlTag, "production", syntheticFlux)
if iter % iterSave == 0:
print "persisting iteration %s" % (iter)
persistValue = (completed, controlSet,controlMap, report)
persist(persistTag, persistValue)
con.controlMin = controlMin
con.controlMax = controlMax
#Persist dependency search
if usePersist:
persistValue = (completed, controlSet,controlMap, report)
persist(persistTag, persistValue)
return (controlMap,controlSet,report)
oligoRecords = SeqIO.parse(open(targetFile), "fasta")
oligoRecords = list(oligoRecords)
#--------------------------------
#Get genomic data for primers
#--------------------------------
if gRecord == None:
config.reflect(configName, seqFac)
gRecord = seqFac.getGenBankSequence(genbankID=None,filename=None)
seqData = gRecord.seq
#---------------------------
# Analysis
#---------------------------
report = Report()
if verbose: print "blasting sequences"
blastedFeatures = seqTools.seqBlastToFeatures(blastDB, blastExe, targetFile, blastType = "blastn",scoreMin = 1e-5)
if verbose: print "finished blasting locations"
if verbose: print "generating recombination oligos"
(targetMap,report,seqRegions) = recFac.generateTargetingOligos(oligoRecords, blastedFeatures, tagRE = targetTag, boundary = boundary, searchSize = searchSize, cutOff = cutOff)
seqRegions = []
for (id,location) in targetMap.items():
low = location - 300
high = location + 300
iSeq = seqData[low:high]
isRecord = SeqRecord(iSeq,id=id)
seqRegions.append(isRecord)
def writeReport(self,ltReport,fluxModel, oPredVal,sPredVal,s2PredVal,neighborhood,iterations,fObjective,resultDir):
if self.verbose: print "Preparing report ..."
report = Report()
reactionNames = fluxModel.network.getOrderedReactionNames()
reactionMap = fluxModel.network.getReactionMap()
for reactionName in reactionNames:
reaction = reactionMap[reactionName]
equation = reaction.getEquation()
pathway = reaction.getAnnotation("Subsystem")
name = reaction.getName()#Currently sensitivity values can be too large for control factors.
report.addElement(reactionName,"name",name)
report.addElement(reactionName,"equation", equation)
report.addElement(reactionName,"Subsystem", pathway)
#--------------------
#Analysis in report
#--------------------
report.addColumnHash("Original", oPredVal)
report.addColumnHash("Synthetic", sPredVal)
report.addColumnHash("Synthetic mBio", s2PredVal)
report.extend(ltReport)
report.addColumnHash("Final Objective", fObjective)
#--------------------
#Write Report
#--------------------
if self.verbose: print "Writing report ..."
outputFileName = resultDir + "RD_" + self.resultTag + "_" + self.modelName + "_" + self.syntheticObjectiveName + "_" + str(neighborhood) + "_" + str(iterations) + "_" + strftime('%Y%m%dT%H%M%S') + ".txt"
writer = ReportWriter()
writer.setFile(outputFileName)
writer.write(report)
writer.closeFile()
if self.verbose: print "Report Written [%s]" % (outputFileName)
return report
