Ejemplo n.º 1
0
 def reactionBounds(self,model,reactionName,objDir = -1.0):
     solver = LPSolver()
     posObjective = {reactionName:objDir}
     negObjective = {reactionName:1.0*objDir}
     
     posPrediction = solver.run(model,posObjective)
     posValue = posPrediction[reactionName]
     
     negPrediction = solver.run(model,negObjective)
     negValue = negPrediction[reactionName]
     
     return (negValue,posValue)
def findBoundaryProduction(originalModel, bounds, combiLimits, objectiveName, productionName):
    model = LinearModel()
    model.extend(originalModel)
    if combiLimits != None:
        for (targetValues,limit) in combiLimits:
            model = addCombinationLimit(model, targetValues,limit)
    #objectiveMap = {objectiveName:-1.0}
    objectiveMap = {productionName:1.0}
    model.addColumnLimits(bounds)
    lp = LPSolver()
    fluxMap = lp.run(model,objectiveMap)
    objectiveValue = fluxMap[objectiveName]
    productionValue = fluxMap[productionName]
    return (fluxMap,objectiveValue,productionValue)
Ejemplo n.º 3
0
 def exportMetabolite(self,model,metaboliteName,max=1e3):
     solver= LPSolver()
     exportTag = "EX_test_export"
     reaction = {metaboliteName:-1.0}
     objective = {exportTag:-1.0}
     
     model.addColumn(exportTag,reaction)
     model.addColumnLimit(exportTag,(0.0,max))        
     prediction = solver.run(model,objective)
     exportValue = prediction[exportTag]
     
     model.removeColumn(exportTag)
     
     return exportValue
def simpleTestOpt(con,originalModel,controlTargets,naturalObjectiveName,syntheticObjectiveName,verbose = False,naturalCoefficient=-0.05):
    '''
    Optimiztaion Tester for depdenency anlaysis
    Construciton object contains union of all libraries which are used by target sets.
    
    '''
    gRMap = con.getGeneTargetMap()
    regulationLibrary = con.regulationLibrary
    objective = {}
    
    for (lib,prefix,target) in controlTargets:
        if gRMap != None:
            if target in gRMap.keys():
                targets = gRMap[target]
            else:
                print "target %s not found in gene map" % (target)
                targets = [target]
        else:
            targets = [target]
        for target in targets:
            if lib in regulationLibrary.keys():
                if target in con.regulationLibrary[lib].keys():
                    controlValue = con.regulationLibrary[lib][target]
                    objective[target] = -1.0 * controlValue
    
    iObjective = dict(objective)
    objective[naturalObjectiveName] = naturalCoefficient
            
    lp = LPSolver()
    prediction = lp.run(originalModel, objective= objective)

    rObjective = iObjective
    if verbose: print "Current objective[%s]: %s" % (str(len(iObjective)),iObjective)
    (iGeneObjective,iOtherObjective) = (None,None)
    if originalModel.controlMap != None:
        (iGeneObjective,iOtherObjective) = originalModel.printGeneObjective(iObjective)
        if verbose: print "Current Genetic objective[%s]: %s" % (str(len(iGeneObjective)),iGeneObjective)
        if verbose: print "Current Other objective: %s" % (iOtherObjective)
        rObjective = iGeneObjective
        
    lp.clear()
    del lp
    
    return (prediction,rObjective)
 def checkSolverScip(self,modelMatrix,predVal,delta=1e-3):
     lp = LPSolver()
     lp.setModel(modelMatrix)
     lp.runIntOpt()
     scipPredVal = lp.getMipPredictionMap()
     (testRows,badRows) = self.checkValues(modelMatrix.data,scipPredVal,modelMatrix.getRowLimits())
     if self.verbose: print "--Debug: number of failed rows %s" % (len(badRows))
     lp.clear()
     solverDiff = self.debugCompareFluxes(predVal,scipPredVal)
     if self.verbose: print "--Debug: difference in glpk / scip %s" % (len(solverDiff))
     
     return (testRows,badRows,solverDiff)
Ejemplo n.º 6
0
def main_function():

    parser = OptionParser()

    parser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=False, help="set verbose mode")

    parser.add_option(
        "--config",
        type="string",
        metavar="FILE",
        dest="config",
        default="redirector.config",
        help="Master configuration file that provides most setting for the Flux Balanace Analysis. Extra variable settings will be ingnored.  Hence the same config can be used for multiple analysis functions",
    )

    parser.add_option(
        "-c",
        "--modelConfig",
        type="string",
        metavar="FILE",
        dest="configFileName",
        default="model_config.txt",
        help="Configuration file which sets model files",
    )

    parser.add_option(
        "-n",
        "--configNames",
        type="string",
        metavar="String",
        dest="configNames",
        default="Default",
        help="A comma separated list of the names of configurations to use, as set out in the configuration file",
    )

    parser.add_option(
        "-m",
        "--modelname",
        type="string",
        metavar="String",
        dest="modelName",
        default="",
        help="Name of model(s) from the modelconfiguration file",
    )

    parser.add_option(
        "-b",
        "--bioObjective",
        type="string",
        dest="bioObj",
        default="Biomass",
        help="Name / ID of biological objective reaction",
        metavar="String",
    )

    parser.add_option(
        "-o",
        "--outputfile",
        dest="outputFileName",
        default=None,
        help="Name of report file to be generated",
        metavar="FILE",
    )

    parser.add_option(
        "-r",
        "--result_directory",
        type="string",
        metavar="directory",
        dest="resultDirectory",
        default="../../results/",
        help="Directory where results are stored",
    )

    parser.add_option(
        "--targets",
        type="string",
        metavar="String",
        dest="targets",
        default="",
        help="List of valid reaction target, if left blank will be automatically filled in from metabolic network file",
    )

    parser.add_option(
        "--report",
        action="store_true",
        dest="isReport",
        default=False,
        help="When this tag is used a report will be generated when the analysis is finished",
        metavar="boolean",
    )

    parser.add_option("--debug", action="store_true", dest="debug", default=False, help="turn on debug mode")

    parser.add_option("--gm", "--GeneMap", action="store_true", dest="useGeneMap", default=False, help="Use Gene Map")

    parser.add_option(
        "--section",
        type="string",
        metavar="String",
        dest="subSections",
        default="",
        help="Comma separated list of sections of the model files to use",
    )

    # -------------------------------
    # Parse options
    # -------------------------------

    (options, args) = parser.parse_args()
    config = ReflectionConfig()
    config.readfp(open("Redirector.config"))

    # ---------------------------
    # configure preset analysis
    # ---------------------------

    configNames = options.configNames.split(",")
    configNames.insert(0, "Redirector Model")
    for name in configNames:
        config.merge(name, "Redirector", append=True)

    # ----------------------------------------
    # reflect options from configuration
    # ----------------------------------------

    config.reflect("Redirector", options)
    config.load("Redirector", options.__dict__, override=False)

    # -----------------------------------------
    # Check and Build Storage Directories
    # -----------------------------------------

    dataDirectory = config.getValue("Redirector", "dataDirectory", classType="".__class__)
    resultsDirectory = config.getValue("Redirector", "resultDirectory", classType="".__class__)
    analysisDirectory = config.getValue("Redirector", "analysisDirectory", classType="".__class__)

    if not os.path.exists(dataDirectory):
        raise IOError("unable to find required data directory" % dataDirectory)
    if not os.path.exists(resultsDirectory):
        os.makedirs(resultsDirectory)
    if not os.path.exists(analysisDirectory):
        os.makedirs(analysisDirectory)

    # ----------------------------
    # Parse Inputs
    # ----------------------------

    verbose = options.verbose
    modelName = options.modelName
    objectiveName = options.bioObj
    outputFileName = options.outputFileName

    """
    #----------------------------------------------------
    # Initialize and set values for tools and factories
    #----------------------------------------------------
    """

    naturalObjective = {objectiveName: -1.0}

    if verbose:
        print "Flux Balanace Analysis Version 1.6"
    if verbose:
        print "Model names: [%s]" % (modelName)
    if verbose:
        print "Parsing data files for [%s]" % (modelName)

    """
    I. Parse data files and configuration settings
    """

    if verbose:
        print "----------------Loading Metabolic Models---------------"
    modelNames = modelName.split(",")
    modelFactory = ModelFactory()
    config.reflect("Redirector", modelFactory)
    (fluxModel, modelMatrix, reducer, geneReduction) = modelFactory.loadModel(modelNames)

    model = modelMatrix
    if verbose:
        print "removing objectives from target set"
    targets = modelMatrix.targets
    if verbose:
        print "Targets List Size [%s]" % len(targets)

    lps = LPSolver()
    predictions = lps.run(model, naturalObjective)
    objectiveValue = predictions[objectiveName]
    lps.clear()

    if verbose:
        print "Optimized Objective [%s] Value [%s]" % (objectiveName, objectiveValue)

    report = fluxModel.getReport()
    report.addColumnHash("Flux", predictions)

    if outputFileName == None or outputFileName == "":
        outputFileName = resultsDirectory + "FBA_%s_%s.txt" % (modelName, strftime("%Y%m%dT%H%M%S"))

    writer = ReportWriter()
    writer.setFile(outputFileName)
    writer.write(report)
    writer.closeFile()

    if verbose:
        print "Report Written [%s]" % (outputFileName)
def productionLevels(originalModel,options,minBio=0.20,verbose=False):
    naturalObjectiveName  = options.bioObj
    syntheticObjectiveName = options.synthObj
    
    cellularObjective = {naturalObjectiveName:-1.0}
    syntheticObjective = {syntheticObjectiveName:-1.0}
    
    lo = LPSolver()
    lo.setModel(originalModel)
    oPredVal = lo.run(objective = cellularObjective)
    oBioVal = oPredVal[naturalObjectiveName]
    oSynthVal = oPredVal[syntheticObjectiveName]

    if verbose: print "Max cellular: Biological [%s] Synthetic: [%s]" % (oBioVal, oSynthVal)
    
    #---------------------------------------
    # Values for Max Synthetic Objective
    #---------------------------------------
    
    sPredVal = lo.run(objective = syntheticObjective)
    sBioVal = sPredVal[naturalObjectiveName]
    sSynthVal = sPredVal[syntheticObjectiveName]
    lo.clear()
    
    if verbose: print "Max synthetic: Biological [%s] Synthetic: [%s]" % (sBioVal, sSynthVal)

    #-----------------------------------
    # Values for minimum Natural objective
    #-----------------------------------
    
    minObjVal = oBioVal*0.20
    originalModel.addColumnLimit(naturalObjectiveName,(minObjVal,None))
    lo = LPSolver()
    s2PredVal = lo.run(model=originalModel,objective = syntheticObjective)
    s2BioVal = s2PredVal[naturalObjectiveName]
    s2SynthVal = s2PredVal[syntheticObjectiveName]
    
    lo.clear()
    
    return (oPredVal,sPredVal,s2PredVal)
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)
def LinearModelVariableBoundarys(originalModel, objectiveName, targets=None, pickleFileName=None, strict=False, minObjectivePercent=None,searchSize=1):
    '''
    Find min and max boundaries for the dependent variables of a linear model. 
    Uses limitMap as constraints on model.
     
    Add cumulative boundary persistence as pickle file function.
    
    @param linearModel: linear model to be analyzed
    @type linearModel: LinearModel
    @param limitMap: map of variable names and lower and upper limits
    @type limitMap: {variableName, (float, float)  
    @param targets: list of variables to perform analysis on
    @type targets: list
    @return: dictionary of lower and upper limits for each variable
    @rtype: {variableName: (lowerlimit, upperlimit)}
    '''
    
    linearModel = LinearModel()
    linearModel.extend(originalModel)
    
    if pickleFileName != None:
        if os.path.isfile(pickleFileName):
            print "loading saved flux boundaries"
            pFile = open(pickleFileName)
            result = pickle.load(pFile)
            pFile.close()
            return result
    
    originalLimits = linearModel.getColumnLimits()
    originalObjectiveLimit = originalLimits[objectiveName]
    objectiveVector = {objectiveName:-1.0}
    
    solver = LPSolver()
    originalValues = solver.run(model=linearModel, objective=objectiveVector)
    originalObjectiveValue = originalValues[objectiveName]
        
    if minObjectivePercent != None:
        minObjectiveValue = originalObjectiveValue * minObjectivePercent
        linearModel.addColumnLimit(objectiveName,(minObjectiveValue,None))
    
    if targets == None:
        targets = linearModel.getColumnNames()
    targets.add(objectiveName)

    print "Searching flux boundaries for %s > %s" % (objectiveName, minObjectiveValue)
    result = {}
    targetValues = targetValueCombinations(targets, [-1.0,1.0])
    controlSubSets = combinations(targetValues,searchSize)
    xcontrolSubSets = set(controlSubSets)
    
    for name in targets:
        nameTag = name
    #   if name not in linearModel.getColumnNames():
    #       print "target %s not found in model"
    #       print "boundary discovery not possible"
    #       continue
        
    #for iTargetValues in xcontrolSubSets:
    #    name = "testControlValue"
    #    nameTag = iTargetValues
    #    linearModel = combinationLimitBuilder(linearModel, iTargetValues, name)
        
        result[name] = (None,None)
        negObjective = {name:1.0}
        posObjective = {name:-1.0}
        
        solver.clearObjective()
        negValues = solver.run(linearModel, objective=negObjective)
        negValue = negValues[name]
        
        solver.clearObjective()
        posValues = solver.run(linearModel, objective=posObjective)
        posValue = posValues[name]
        
        delta = 1e-4
        if posValue != 0 or negValue !=0:
            pass
        
        if False:
            originalValue = originalValues[name]
            originalLimit = originalLimits[name]
        
            if not (negValue - delta <= originalValue <= posValue + delta):
                print "original value not in boundary"
                print "objective value [%s] (%s) %s <= %s <= %s (%s)" % (name, originalLimit[0], negValue, originalValue, posValue, originalLimit[1])
                #print "value neg code %s pos code %s" % (nscode, pscode)
                (negValue,posValue) = (originalLimit[0],originalLimit[1])
            else:
                #print "objective value [%s] (%s) %s <= %s <= %s (%s)" % (name, originalLimit[0], negValue, originalValue, posValue, originalLimit[1])
                pass
                
            if negValue == None or negValue == float("-inf"):
                continue
    
            if posValue == None or posValue == float("-inf"):
                continue
        
        result[nameTag] = (negValue,posValue)
        print "%s < [%s] < %s " % (negValue,nameTag,posValue)
    
    if pickleFileName != None:
        pFile = open(pickleFileName,'w')
        pickle.dump(result, pFile)
        pFile.close()
        
    solver.clear()
    del solver
    
    linearModel.addColumnLimit(objectiveName,originalObjectiveLimit)
    #targets.remove(objectiveName)
        
    return result