def test_WriteL3SBML_Model_substanceUnits(self): expected = wrapSBML_L3v1(" <model substanceUnits=\"mole\"/>\n") m = self.D.createModel("") m.setSubstanceUnits("mole") self.S = libsbml.writeSBMLToString(self.D) self.assertEqual(True, self.equals(expected, self.S)) pass
def _parse_yaml_dict(yaml_dict) -> str: """ Generates a string, containing the SBML from a yaml_dict. Arguments: yaml_dict: dictionary, containing to the yaml file with the ODEs specification. Returns: sbml_string: a string containing the ODEs in SBML format. """ try: document = sbml.SBMLDocument(3, 1) except ValueError: raise SystemExit('Could not create SBMLDocument object') model = document.createModel() model = _create_compartment(model) _convert_yaml_blocks_to_sbml(model, yaml_dict) # check consistency and give warnings for errors in SBML: if document.checkConsistency(): for error_num in range(document.getErrorLog().getNumErrors()): if not document.getErrorLog().getError(error_num).isWarning(): warnings.warn( document.getErrorLog().getError(error_num).getMessage(), RuntimeWarning) sbml_string = sbml.writeSBMLToString(document) return sbml_string
def xpath_expressions_exist(doc, xpath_expressions): # type: (libsbml.SBMLDocument, List[str]) -> bool sbml = libsbml.writeSBMLToString(doc) tree = etree.fromstring(sbml.encode('utf-8')) result = True for xpath in xpath_expressions: if ':' not in xpath: logging.warning( f"no prefix used in xpath expression: {xpath} this likely cannot be resolved" ) try: elements = tree.xpath( xpath, namespaces={'sbml': doc.getSBMLNamespaces().getURI()}) num_elements = len(elements) if num_elements == 0: logging.error(f"no match for xpath expression: {xpath}") result = False if num_elements > 1: logging.warning( f"more than one match for xpath expression, this is not supported by many tools: {xpath}" ) except TypeError: logging.error(f"invalid xpath expression: {xpath}") result = False return result
def test_WriteL3SBML_Model_timeUnits(self): expected = wrapSBML_L3v1(" <model timeUnits=\"second\"/>\n") m = self.D.createModel("") m.setTimeUnits("second") self.S = libsbml.writeSBMLToString(self.D) self.assertEqual(True, self.equals(expected, self.S)) pass
def test_WriteL3SBML_Model(self): expected = wrapSBML_L3v1(" <model/>\n" ) m = self.D.createModel("") self.S = libsbml.writeSBMLToString(self.D) self.assertEqual( True, self.equals(expected,self.S) ) pass
def CreateExample3(Repetitions = 1): "Create SBML Array simulation example 3" PopulationSize = 100 TimeLimit = 10 (NameSpace,Document,Model,IndividualsUnit,SimulationSize,InstructionNumber,DefineDimension,Random,Time) = InitExample(PopulationSize*Repetitions) StateList = ['Healthy','Sick','Dead'] DefineStates(Model, StateList, SimulationSize) DefineParamArray(Model,'Male',SimulationSize) DefineInitialAssignment(Container = Model, Symbol = 'Healthy', Size = SimulationSize, MathExpression = 'selector(vector('+str([1]*PopulationSize*Repetitions)[1:-1]+ '),d0)') DefineInitialAssignment(Container = Model, Symbol = 'Sick', Size = SimulationSize, MathExpression = 'selector(vector('+str([0]*PopulationSize*Repetitions)[1:-1]+ '),d0)') DefineInitialAssignment(Container = Model, Symbol = 'Dead', Size = SimulationSize, MathExpression = 'selector(vector('+str([0]*PopulationSize*Repetitions)[1:-1]+ '),d0)') DefineInitialAssignment(Container = Model, Symbol = 'Male', Size = SimulationSize, MathExpression = 'selector(vector('+str(([0]*(PopulationSize/2)+[1]*(PopulationSize/2))*Repetitions)[1:-1]+ '),d0)') # terminate event at start of loop DefineTerminalEvent (Model = Model, TerminalStates = ['Dead'], Size = SimulationSize, TimeLimit=TimeLimit) TransitionFormula(Model = Model, FromStates = [ 'Healthy' ], ToStates = [ 'Dead', 'Sick'] , Probabilities = [ [ '0.01' ,'0.1*(1+selector(Male,d0))'] ] , Size = SimulationSize, InstructionNumber = 1, NextLine = 0) TransitionFormula(Model = Model, FromStates = [ 'Sick' ], ToStates = [ 'Healthy','Dead'] , Probabilities = [ [ '0.1','0.3' ] ] , Size = SimulationSize, InstructionNumber = 1, NextLine = 0) return libsbml.writeSBMLToString(Document)
def test_write_sbml_file(self): import libsbml from biocrnpyler import ChemicalReactionNetwork from biocrnpyler import Species from biocrnpyler import Reaction s1 = Species(name='test_species1') s2 = Species(name='test_species2') species_list = [s1, s2] rx1 = Reaction(inputs=[s1], outputs=[s2], k=0.1) rxn_list = [rx1] crn = ChemicalReactionNetwork(species=species_list, reactions=rxn_list) document, _ = crn.generate_sbml_model() sbml_string = libsbml.writeSBMLToString(document) file_name = 'test_sbml.xml' with patch("builtins.open", new=mock_open()) as _file: crn.write_sbml_file(file_name) _file.assert_called_once_with(file_name, 'w') _file().write.assert_called_once_with(sbml_string)
def test_WriteL3SBML_SBMLDocument_L3v1(self): expected = wrapXML( "<sbml xmlns=\"http://www.sbml.org/sbml/level3/version1/core\" " + "level=\"3\" version=\"1\"/>\n") self.S = libsbml.writeSBMLToString(self.D) self.assertEqual(True, self.equals(expected, self.S)) pass
def test_WriteL3SBML_elements(self): expected = wrapSBML_L3v1( " <model>\n" + " <listOfFunctionDefinitions>\n" + " <functionDefinition/>\n" + " </listOfFunctionDefinitions>\n" + " <listOfUnitDefinitions>\n" + " <unitDefinition/>\n" + " </listOfUnitDefinitions>\n" + " <listOfCompartments>\n" + " <compartment/>\n" + " </listOfCompartments>\n" + " <listOfSpecies>\n" + " <species/>\n" + " </listOfSpecies>\n" + " <listOfParameters>\n" + " <parameter/>\n" + " </listOfParameters>\n" + " <listOfInitialAssignments>\n" + " <initialAssignment/>\n" + " </listOfInitialAssignments>\n" + " <listOfRules>\n" + " <algebraicRule/>\n" + " </listOfRules>\n" + " <listOfConstraints>\n" + " <constraint/>\n" + " </listOfConstraints>\n" + " <listOfReactions>\n" + " <reaction/>\n" + " </listOfReactions>\n" + " <listOfEvents>\n" + " <event/>\n" + " </listOfEvents>\n" + " </model>\n") m = self.D.createModel() m.createUnitDefinition() m.createFunctionDefinition() m.createCompartment() m.createEvent() m.createParameter() m.createAlgebraicRule() m.createInitialAssignment() m.createConstraint() m.createReaction() m.createSpecies() self.S = libsbml.writeSBMLToString(self.D) self.assertEqual(True, self.equals(expected, self.S)) pass
def test_WriteL3SBML_Model_conversionFactor(self): expected = wrapSBML_L3v1(" <model conversionFactor=\"p\"/>\n") m = self.D.createModel("") m.setConversionFactor("p") self.S = libsbml.writeSBMLToString(self.D) self.assertEqual(True, self.equals(expected, self.S)) pass
def get_sbml(self) -> str: """Return SBML string of the model. :return: SBML string """ if self.doc is None: self.create_sbml() return libsbml.writeSBMLToString(self.doc)
def toSBML(self): errors = self.document.checkConsistency(); if (errors > 0): for i in range(errors): print self.document.getError(i).getSeverityAsString(), ": ", self.document.getError(i).getMessage(); return libsbml.writeSBMLToString(self.document);
def petab_problem(): # create test model document = libsbml.SBMLDocument(3, 1) model = document.createModel() model.setTimeUnits("second") model.setExtentUnits("mole") model.setSubstanceUnits('mole') p = model.createParameter() p.setId('fixedParameter1') p.setName('FixedParameter1') p = model.createParameter() p.setId('observable_1') p.setName('Observable 1') with tempfile.NamedTemporaryFile(mode='w', delete=False) as fh: sbml_file_name = fh.name fh.write(libsbml.writeSBMLToString(document)) measurement_df = pd.DataFrame( data={ 'observableId': ['obs1', 'obs2'], 'observableParameters': ['', 'p1;p2'], 'noiseParameters': ['p3;p4', 'p5'] }) with tempfile.NamedTemporaryFile(mode='w', delete=False) as fh: measurement_file_name = fh.name measurement_df.to_csv(fh, sep='\t', index=False) condition_df = pd.DataFrame( data={ 'conditionId': ['condition1', 'condition2'], 'conditionName': ['', 'Condition 2'], 'fixedParameter1': [1.0, 2.0] }) condition_df.set_index('conditionId', inplace=True) with tempfile.NamedTemporaryFile(mode='w', delete=False) as fh: condition_file_name = fh.name condition_df.to_csv(fh, sep='\t', index=True) parameter_df = pd.DataFrame( data={ 'parameterId': ['dynamicParameter1', 'dynamicParameter2'], 'parameterName': ['', '...'], # ... }) with tempfile.NamedTemporaryFile(mode='w', delete=False) as fh: parameter_file_name = fh.name parameter_df.to_csv(fh, sep='\t', index=False) problem = petab.Problem.from_files(sbml_file=sbml_file_name, measurement_file=measurement_file_name, condition_file=condition_file_name, parameter_file=parameter_file_name) return problem
def test_WriteL3SBML_Model_timeUnits(self): expected = wrapSBML_L3v1(" <model timeUnits=\"second\"/>\n" ) m = self.D.createModel("") m.setTimeUnits("second") self.S = libsbml.writeSBMLToString(self.D) self.assertEqual( True, self.equals(expected,self.S) ) pass
def writerpSBMLtar(rpsbml_paths, outTar): with tarfile.open(outTar, 'w:xz') as tf: for rpsbml_name in rpsbml_paths: data = libsbml.writeSBMLToString(rpsbml_paths[rpsbml_name].document).encode('utf-8') fiOut = BytesIO(data) info = tarfile.TarInfo(rpsbml_name) info.size = len(data) tf.addfile(tarinfo=info, fileobj=fiOut)
def toSBML(self, disable_warnings=True): errors = self.document.checkConsistency() if (errors > 0) and not disable_warnings: for i in range(errors): print self.document.getError(i).getSeverityAsString( ), ": ", self.document.getError(i).getMessage() return libsbml.writeSBMLToString(self.document)
def toSBML(self): errors = self.document.checkConsistency() if (errors > 0): for i in range(errors): print self.document.getError(i).getSeverityAsString( ), ": ", self.document.getError(i).getMessage() return libsbml.writeSBMLToString(self.document)
def test_WriteL3SBML_Model_conversionFactor(self): expected = wrapSBML_L3v1(" <model conversionFactor=\"p\"/>\n" ) m = self.D.createModel("") m.setConversionFactor("p") self.S = libsbml.writeSBMLToString(self.D) self.assertEqual( True, self.equals(expected,self.S) ) pass
def test_WriteL3SBML_Model_substanceUnits(self): expected = wrapSBML_L3v1(" <model substanceUnits=\"mole\"/>\n" ) m = self.D.createModel("") m.setSubstanceUnits("mole") self.S = libsbml.writeSBMLToString(self.D) self.assertEqual( True, self.equals(expected,self.S) ) pass
def rp2Reader_mem(rpreader, rp2_pathways, rp2paths_pathways, rp2paths_compounds, upper_flux_bound, lower_flux_bound, maxRuleIds, pathway_id, compartment_id, species_group_id, sink_species_group_id, pubchem_search, outputTar): """The main function to parse the files without writing to HDD :param rpreader: rpReader object :param rp2_pathways: The RetroPath2.0 results scope file :param rp2paths_pathways: The rp2paths result pathway (out_paths) file :param rp2paths_compounds: The rp2paths result compounds file :param upper_flux_bound: The default upper flux bound (Default: 999999) :param lower_flux_bound: The default lower flux bound (Default: 0) :param maxRuleIds: The maximal number of rules associated with each step (Default: 2) :param pathway_id: The Groups heterologous pathway id (Default: rp_pathway) :param compartment_id: The compartment SBML id (Default: MNXC3) :param species_group_id: The Groups id of the central species (Default: central_species) :param sink_species_group_id: The Groups id of the rp_sink_species (Default: rp_sink_species) :param pubchem_search: Use the pubchem database to search for missing cross reference (Default: False) :param outputTar: The output collection of rpSBML files :type rpreader: rpReader :type rp2_pathways: str :type rp2paths_pathways: str :type rp2paths_compounds: str :type upper_flux_bound: int :type lower_flux_bound: int :type maxRuleIds: int :type pathway_id: str :type compartment_id: str :type species_group_id: str :type sink_species_group_id: str :type pubchem_search: bool :type outputTar: str :rtype: bool :return: Success or failure of the function """ rpsbml_paths = rpreader.rp2ToSBML(rp2_pathways, rp2paths_pathways, rp2paths_compounds, None, upper_flux_bound, lower_flux_bound, maxRuleIds, pathway_id, compartment_id, species_group_id, sink_species_group_id, pubchem_search) #pass the SBML results to a tar if rpsbml_paths == {}: logging.error('rpReader did not generate any results') return False #outputTar = io.BytesIO() #with open(outputTar, 'w:xz') as tf: with tarfile.open(fileobj=outputTar, mode='w:gz') as tf: for rpsbml_name in rpsbml_paths: data = libsbml.writeSBMLToString( rpsbml_paths[rpsbml_name].document).encode('utf-8') fiOut = io.BytesIO(data) info = tarfile.TarInfo(name=rpsbml_name) info.size = len(data) tf.addfile(tarinfo=info, fileobj=fiOut) return True
def test_WriteL3SBML_Model_otherUnits(self): expected = wrapSBML_L3v1(" <model volumeUnits=\"litre\" areaUnits=\"area\" lengthUnits=\"metre\"/>\n" ) m = self.D.createModel("") m.setVolumeUnits("litre") m.setAreaUnits("area") m.setLengthUnits("metre") self.S = libsbml.writeSBMLToString(self.D) self.assertEqual( True, self.equals(expected,self.S) ) pass
def writerpSBMLzip(rpsbml_paths, outZip): zip_buffer = io.BytesIO() #with zipfile.ZipFile(zip_buffer, "a", zipfile.ZIP_DEFLATED, False) as zip_file: with zipfile.ZipFile(zip_buffer, mode="a", compression=zipfile.ZIP_DEFLATED, compresslevel=9) as zip_file: for rpsbml_name in rpsbml_paths: data = libsbml.writeSBMLToString(rpsbml_paths[rpsbml_name].document).encode('utf-8') data = io.BytesIO(bytes(data)) zip_file.writestr(rpsbml_name, data.getvalue()) with open(outZip, 'wb') as f: f.write(zip_buffer.getvalue())
def runSingleSBML(rpcofactors, member_name, rpsbml_string, path_id, compartment_id): #open one of the rp SBML files rpsbml = rpSBML.rpSBML(member_name, libsbml.readSBMLFromString(rpsbml_string)) #rpcofactors = rpRanker.rpCofactors() if rpcofactors.addCofactors(rpsbml, compartment_id, path_id): return libsbml.writeSBMLToString(rpsbml.document).encode('utf-8') else: return ''
def test_write_sbml_file(self): document, _ = self.crn.generate_sbml_model() sbml_string = libsbml.writeSBMLToString(document) file_name = 'test_sbml.xml' with patch("builtins.open", new=mock_open()) as _file: self.crn.write_sbml_file(file_name) _file.assert_called_once_with(file_name, 'w') _file().write.assert_called_once_with(sbml_string)
def main(): '''COMMENT''' terpenoid_pathway = 'ec00900' terpenoid_ec_numbers = ['2.3.1.9', '2.3.3.10', '1.1.1.34', '2.7.1.36', '2.7.4.2', '4.1.1.33', '5.3.3.2', '2.5.1.1'] monoterpenoid_pathway = 'ec00902' monoterpenoid_ec_numbers = ['4.2.3.16'] pathway_ec_numbers = {terpenoid_pathway: terpenoid_ec_numbers, monoterpenoid_pathway: monoterpenoid_ec_numbers} document = builder.build(pathway_ec_numbers) print libsbml.writeSBMLToString(document)
def write_sbml_to_string(self): """ Write the SBML file. First create clean SBML file. :param sbml_out: :type sbml_out: :return: :rtype: """ self._create_sbml() return libsbml.writeSBMLToString(self.doc)
def create_model(): document = libsbml.SBMLDocument(3, 1) model = document.createModel() model.setTimeUnits("second") model.setExtentUnits("mole") model.setSubstanceUnits('mole') create_unit_definitions(model) c1 = model.createCompartment() c1.setId('c1') c1.setConstant(True) c1.setSize(1) c1.setSpatialDimensions(3) c1.setUnits('litre') create_species(model, 'x1', 'c1', False, 0.1) create_species(model, 'x2', 'c1', False, 0.4) create_species(model, 'x3', 'c1', False, 0.7) #TODO: initial amounts should be parameters create_parameter(model, 'p1', True, 1.0, 'litre2_per_mole_per_second') create_parameter(model, 'p2', True, 0.5, 'litre2_per_mole_per_second') create_parameter(model, 'p3', True, 0.4, 'litre_per_second') create_parameter(model, 'p4', True, 2.0, 'litre_per_second') create_parameter(model, 'p5', True, 0.1, 'mole_per_second') create_parameter(model, 'k0', True, 1.0, 'litre_per_second') create_reaction(model, 'r1', [(2, 'x1')], [(1, 'x2')], 'p1 * x1^2') create_reaction(model, 'r2', [(1, 'x1'), (1, 'x2')], [(1, 'x3')], 'p2 * x1 * x2') create_reaction(model, 'r3', [(1, 'x2')], [(2, 'x1')], 'p3 * x2') create_reaction(model, 'r4', [(1, 'x3')], [(1, 'x1'), (1, 'x2')], 'p4 * x3') create_reaction(model, 'r5', [(1, 'x3')], [], 'k0 * x3') create_reaction(model, 'r6', [], [(1, 'x1')], 'p5') # S -2 -1 2 1 0 1 v1: p1 x1^2 # 1 -1 -1 1 0 0 v2: p2 x1 x2 # 0 1 0 -1 -1 0 v3: p3 x2 # v4: p4 x3 # v5: k0 x3 # v6: p5 # R1: 2X1 -> X2 # R2: X1 + X2 -> X3 # R3: X2 -> 2X1 # R4: X3 -> X1 + X2 # R5: X3 -> # R6: -> X1 return libsbml.writeSBMLToString(document)
def runSingleSBML(member_name, rpsbml_string, inSBML, isMerge, path_id): #open one of the rp SBML files input_rpsbml = rpSBML.rpSBML('inputMergeModel', libsbml.readSBMLFromFile(inSBML)) rpsbml = rpSBML.rpSBML(member_name, libsbml.readSBMLFromString(rpsbml_string)) #read the input GEM sbml model #input_rpsbml = rpSBML.rpSBML('inputMergeModel', libsbml.readSBMLFromString(inSBML_string)) #print(input_rpsbml) #print(input_rpsbml.model) rpsbml.mergeModels(input_rpsbml.model) rpfba = rpFBA.rpFBA(input_rpsbml) rpfba.allObj(path_id) if isMerge: ##### pass FBA results to the original model #### groups = rpfba.rpsbml.model.getPlugin('groups') rp_pathway = groups.getGroup(path_id) for member in rp_pathway.getListOfMembers(): reacFBA = rpfba.rpsbml.model.getReaction(member.getIdRef()) reacIN = rpsbml.model.getReaction(member.getIdRef()) reacIN.setAnnotation(reacFBA.getAnnotation()) return libsbml.writeSBMLToString(rpsbml.document).encode('utf-8') else: return libsbml.writeSBMLToString(input_rpsbml.document).encode('utf-8')
def test_WriteL3SBML_elements(self): expected = wrapSBML_L3v1(" <model>\n" + " <listOfFunctionDefinitions>\n" + " <functionDefinition/>\n" + " </listOfFunctionDefinitions>\n" + " <listOfUnitDefinitions>\n" + " <unitDefinition/>\n" + " </listOfUnitDefinitions>\n" + " <listOfCompartments>\n" + " <compartment constant=\"true\"/>\n" + " </listOfCompartments>\n" + " <listOfSpecies>\n" + " <species hasOnlySubstanceUnits=\"false\"" + " boundaryCondition=\"false\" constant=\"false\"/>\n" + " </listOfSpecies>\n" + " <listOfParameters>\n" + " <parameter constant=\"true\"/>\n" + " </listOfParameters>\n" + " <listOfInitialAssignments>\n" + " <initialAssignment/>\n" + " </listOfInitialAssignments>\n" + " <listOfRules>\n" + " <algebraicRule/>\n" + " </listOfRules>\n" + " <listOfConstraints>\n" + " <constraint/>\n" + " </listOfConstraints>\n" + " <listOfReactions>\n" + " <reaction reversible=\"true\" fast=\"false\"/>\n" + " </listOfReactions>\n" + " <listOfEvents>\n" + " <event/>\n" + " </listOfEvents>\n" + " </model>\n") m = self.D.createModel() m.createUnitDefinition() m.createFunctionDefinition() m.createCompartment() m.createEvent() m.createParameter() m.createAlgebraicRule() m.createInitialAssignment() m.createConstraint() m.createReaction() m.createSpecies() self.S = libsbml.writeSBMLToString(self.D) self.assertEqual( True, self.equals(expected,self.S) ) pass
def test_write_sbml_file(self): s1, s2 = Species("S1"), Species("S2") rx1 = Reaction.from_massaction(inputs=[s1], outputs=[s2], k_forward=0.1) crn = ChemicalReactionNetwork(species=[s1, s2], reactions=[rx1]) model_id = 'test_model' document, _ = crn.generate_sbml_model(model_id=model_id) sbml_string = libsbml.writeSBMLToString(document) file_name = 'test_sbml.xml' with patch("builtins.open", new=mock_open()) as _file: crn.write_sbml_file(file_name, model_id=model_id) _file.assert_called_once_with(file_name, 'w') _file().write.assert_called_once_with(sbml_string)
def export(self, level=(3, 2)): """ Export the SBML for the PySB model associated with the exporter Requires libsbml package. Parameters ---------- level: (int, int) The SBML level and version to use. The default is SBML level 3, version 2. Conversion to other levels/versions may not be possible or may lose fidelity. Returns ------- string String containing the SBML output. """ return libsbml.writeSBMLToString(self.convert(level=level))
def write_sbml_file(self, file_name=None, stochastic_model=False, **keywords) -> bool: """"Writes CRN object to a SBML file :param file_name: name of the file where the SBML model gets written :param stochastic_model: export an SBML file which ready for stochastic simulations :param keywords: keywords that passed into generate_sbml_model() :return: bool, show whether the writing process was successful """ document, _ = self.generate_sbml_model( stochastic_model=stochastic_model, **keywords) sbml_string = libsbml.writeSBMLToString(document) with open(file_name, 'w') as f: f.write(sbml_string) return True
def simulate_with_roadrunner(self, timepoints: List[float], initial_condition_dict: Dict[str, float] = None, return_roadrunner=False, check_validity=True): """To simulate using roadrunner. Arguments: timepoints: The array of time points to run the simulation for. initial_condition_dict: Returns the results array as returned by RoadRunner OR a Roadrunner model object. Refer to the libRoadRunner simulator library documentation for details on simulation results: (http://libroadrunner.org/)[http://libroadrunner.org/] NOTE : Needs roadrunner package installed to simulate. """ res_ar = None try: import roadrunner import io document, _ = self.generate_sbml_model( stochastic_model=False, check_validity=check_validity) sbml_string = libsbml.writeSBMLToString(document) # write the sbml_string into a temporary file in memory instead of a file string_out = io.StringIO() string_out.write(sbml_string) # use the temporary file in memory to load the model into libroadrunner rr = roadrunner.RoadRunner(string_out.getvalue()) if initial_condition_dict: for species, value in initial_condition_dict.items(): rr.model[f"init([{species}])"] = value if return_roadrunner: return rr else: result = rr.simulate(timepoints[0], timepoints[-1], len(timepoints)) res_ar = result except ModuleNotFoundError: warnings.warn( 'libroadrunner was not found, please install libroadrunner') return res_ar
def convertToSBMLModel( anEml, aBaseName, aLevel, aVersion ): ''' this function is called from ecell3-eml2sbml ''' global aSBMLLevel aSBMLLevel = aLevel aSBMLDocument = libsbml.SBMLDocument() aSBMLDocument.setLevelAndVersion( int( aLevel ), int( aVersion ) ) aSBMLModel = aSBMLDocument.createModel() aSBMLModel.setId( aBaseName ) createModel( anEml, aSBMLModel ) # set abogadro number and EmptySet to SBML model setEssentialEntity( aSBMLModel ) return libsbml.writeSBMLToString( aSBMLDocument )
def convertToSBMLModel(anEml, aBaseName, aLevel, aVersion): ''' this function is called from ecell3-eml2sbml ''' global aSBMLLevel aSBMLLevel = aLevel aSBMLDocument = libsbml.SBMLDocument() aSBMLDocument.setLevelAndVersion(int(aLevel), int(aVersion)) aSBMLModel = aSBMLDocument.createModel() aSBMLModel.setId(aBaseName) createModel(anEml, aSBMLModel) # set abogadro number and EmptySet to SBML model setEssentialEntity(aSBMLModel) return libsbml.writeSBMLToString(aSBMLDocument)
def clamp_species(r: roadrunner.RoadRunner, sids, boundary_condition=True) -> roadrunner.RoadRunner: """ Clamp/Free specie(s) via setting boundaryCondition=True/False. This requires changing the SBML and ODE system. :param r: roadrunner.RoadRunner :param sids: sid or iterable of sids :param boundary_condition: boolean flag to clamp (True) or free (False) species :return: modified roadrunner.RoadRunner """ # get model for current SBML state sbml_str = r.getCurrentSBML() doc = libsbml.readSBMLFromString(sbml_str) # type: libsbml.SBMLDocument model = doc.getModel() # type: libsbml.Model if isinstance(sids, str): sids = [sids] for sid in sids: # set boundary conditions sbase = model.getElementBySId(sid) # type: libsbml.SBase if not sbase: logging.error("No element for SId in model: {}".format(sid)) return None else: if sbase.getTypeCode() == libsbml.SBML_SPECIES: species = sbase # type: libsbml.Species species.setBoundaryCondition(boundary_condition) else: logging.error( "SId in clamp does not match species: {}".format(sbase)) return None # create modified roadrunner instance sbmlmod_str = libsbml.writeSBMLToString(doc) rmod = load_model(sbmlmod_str) # type: roadrunner.RoadRunner set_timecourse_selections(rmod, r.timeCourseSelections) return rmod
def CreateExample4(Repetitions = 1): "Create SBML Array simulation example 4" PopulationSize = 100 TimeLimit = 10 (NameSpace,Document,Model,IndividualsUnit,SimulationSize,InstructionNumber,DefineDimension,Random,Time) = InitExample(PopulationSize*Repetitions) StateList = ['Healthy','Sick','Dead'] DefineStates(Model, StateList, SimulationSize) DefineParamArray(Model,'Male',SimulationSize) DefineParamArray(Model,'Age',SimulationSize) DefineInitialAssignment(Container = Model, Symbol = 'Healthy', Size = SimulationSize, MathExpression = 'selector(vector('+str([1]*PopulationSize*Repetitions)[1:-1]+ '),d0)') DefineInitialAssignment(Container = Model, Symbol = 'Sick', Size = SimulationSize, MathExpression = 'selector(vector('+str([0]*PopulationSize*Repetitions)[1:-1]+ '),d0)') DefineInitialAssignment(Container = Model, Symbol = 'Dead', Size = SimulationSize, MathExpression = 'selector(vector('+str([0]*PopulationSize*Repetitions)[1:-1]+ '),d0)') DefineInitialAssignment(Container = Model, Symbol = 'Male', Size = SimulationSize, MathExpression = 'selector(vector('+str(([0]*(PopulationSize/2)+[1]*(PopulationSize/2))*Repetitions)[1:-1]+ '),d0)') DefineInitialAssignment(Container = Model, Symbol = 'Age', Size = SimulationSize, MathExpression = 'selector(vector('+str(list(range(1,(PopulationSize/2)+1))*2*Repetitions)[1:-1]+ '),d0)') # terminate event at start of loop DefineTerminalEvent (Model = Model, TerminalStates = ['Dead'], Size = SimulationSize, TimeLimit=TimeLimit) Assignments = ( [ ('Age', 'selector(Age,d0)+1', (0,'variable','d0' ) ) , ] , [] ) DefineDualEventArrays(Container=Model, Size = SimulationSize, Name='Age Increase', InstructionNumber=1, TriggerFormulas = ('true','false'), LeadPriority = 0, DelayFormula='1', Assignments=Assignments) TransitionFormula(Model = Model, FromStates = [ 'Healthy' ], ToStates = [ 'Dead', 'Sick'] , Probabilities = [ [ 'selector(Age,d0)/1000' ,'min(0.8,0.1*(1+selector(Male,d0))+0.01*selector(Age,d0))'] ] , Size = SimulationSize, InstructionNumber = 2, NextLine = 0) TransitionFormula(Model = Model, FromStates = [ 'Sick' ], ToStates = [ 'Healthy','Dead'] , Probabilities = [ [ '0.1','min(0.9, 0.01*selector(Age,d0) + 0.2*selector(Male,d0))' ] ] , Size = SimulationSize, InstructionNumber = 2, NextLine = 0) return libsbml.writeSBMLToString(Document)
def getComponentSBML(self): ''' Returns list of SBML models generated from each model reaction ''' import libsbml return [libsbml.writeSBMLToString(doc) for doc in self.submodels]
def test_WriteL3SBML_SBMLDocument_L3v1(self): expected = wrapXML("<sbml xmlns=\"http://www.sbml.org/sbml/level3/version1/core\" " + "level=\"3\" version=\"1\"/>\n") self.S = libsbml.writeSBMLToString(self.D) self.assertEqual( True, self.equals(expected,self.S) ) pass
def flattenExternalModelDefinitions(doc): """ Converts all ExternalModelDefinitions to ModelDefinitions. I.e. the definition of models in external files are read and directly included in the top model. The resulting comp model consists than only of a single file. The model refs in the submodel do not change in the process, so no need to update the submodels. :param doc: SBMLDocument :return: SBMLDocument with ExternalModelDefinitions replaced """ # FIXME: handle /multiple levels of hierarchies recursively (ExternalModelDefinitions of submodels) model = doc.getModel() if model is None: return doc comp_doc = doc.getPlugin("comp") emd_list = comp_doc.getListOfExternalModelDefinitions() # no ExternalModelDefinitions if (emd_list is None) or (len(emd_list) == 0): return doc # ExternalModelDefinitions set as ModelDefinitions emd_ids = [] mds = [] for emd in emd_list: emd_ids.append(emd.getId()) # get the model definition from the model ref_model = emd.getReferencedModel() # store model definition md = libsbml.ModelDefinition(ref_model) mds.append(md) packages = [] for emd in emd_list: # get the model definition from the model ref_model = emd.getReferencedModel() ref_doc = ref_model.getSBMLDocument() # print('\n', ref_model) for k in range(ref_doc.getNumPlugins()): plugin = ref_doc.getPlugin(k) uri = plugin.getURI() prefix = plugin.getPrefix() name = plugin.getPackageName() required = None if ref_doc.isSetPackageRequired(name): required = ref_doc.getPackageRequired(name) packages.append({ 'model': ref_model, 'uri': uri, 'prefix': prefix, 'name': name, 'required': required }) # remove emds from model (do not remove while iterating over the list) for emd_id in emd_ids: comp_doc.removeExternalModelDefinition(emd_id) # activate all the packages from pprint import pprint pprint(packages) for pdict in packages: doc.enablePackage(pdict['uri'], pdict['prefix'], True) doc.setPackageRequired(pdict['name'], pdict['required']) # now add the model definitions for md in mds: comp_doc.addModelDefinition(md) sbml_str = libsbml.writeSBMLToString(doc) doc = libsbml.readSBMLFromString(sbml_str) # replacement finished, now go through all ModelDefinitions # and add things the packages require print("-"*80) for k in range(doc.getNumPlugins()): plugin = doc.getPlugin(k) name = plugin.getPackageName() print(name, '\n') md_list = comp_doc.getListOfModelDefinitions() for md_model in md_list: # if a package needs something on # a model we have to write it on all ModelDefinitions # this will break on a package per package basis ! We know about fbc it needs # a strict tag so writing this here if name == "fbc": # for some ModelDefinitions we don't get the fbc Plugin ??? fbc_model = md_model.getPlugin(name) print('\tModel:', md_model) print('\tFBCModelPlugin:', fbc_model, type(fbc_model)) # setting because it is required (if unlucky additional info required) # but we can't set it because we can't access the FBCModelPlugins of the ModelDefinitions if fbc_model is not None: if not fbc_model.isSetStrict(): fbc_model.setStrict(False) else: print("WARNING: This should never happen. All ModelDefinitions should have a FBCModelPlugin") doc.checkInternalConsistency() doc.printErrors() return doc
# success probability of Geometric-1 up_mean_geo1 = up.createUncertParameter() # type: libsbml.UncertParameter up_mean_geo1.setType(libsbml.DISTRIB_UNCERTTYPE_EXTERNALPARAMETER) up_mean_geo1.setName("success probability of Geometric 1") up_mean_geo1.setValue(0.4) up_mean_geo1.setDefinitionURL("http://www.probonto.org/ontology#PROB_k0000789") return doc if __name__ == "__main__": functions = [ # distrib_normal, # distrib_all, uncertainty, ] for f_creator in functions: name = f_creator.__name__ print(name) # distrib_example1() doc = f_creator() sbml = libsbml.writeSBMLToString(doc) print("-" * 80) print(sbml) print("-" * 80) sbml_path = "./{}.xml".format(name) libsbml.writeSBMLToFile(doc, sbml_path) validation.check_doc(doc)
def __repr__(self): return libsbml.writeSBMLToString(self.document)
def test_sbml(self): fwd = Direction.forward() rev = Direction.reversible() a = M("A_c") b = M("B_c") c = M("C_e") e = M("E_e", boundary=True) model = Model() model.reactions = [ R("R1", 1*a, 3*b, direction=fwd, bounds=Bounds(-100, 100)), R("R2", 1*c, 3*b, direction=fwd, bounds=Bounds(-100, 100)), R("R3", 1*b + 1*c, 1*e, direction=rev, bounds=Bounds(-100, 100))] import libsbml import converter sbml = converter.Bioopt2SbmlConverter().convert(model) sbml_export = libsbml.writeSBMLToString(sbml) doc = libsbml.readSBMLFromString(sbml_export) self.assertEquals(0, doc.getNumErrors()) exp_export = """<?xml version="1.0" encoding="UTF-8"?> <sbml xmlns="http://www.sbml.org/sbml/level2/version3" level="2" version="3"> <model> <listOfUnitDefinitions> <unitDefinition id="mmol_per_gDW_per_hr"> <listOfUnits> <unit kind="mole" scale="-3"/> <unit kind="second" exponent="-1" multiplier="0.00027778"/> </listOfUnits> </unitDefinition> </listOfUnitDefinitions> <listOfCompartments> <compartment id="C_0001" name="c"/> <compartment id="C_0002" name="e"/> </listOfCompartments> <listOfSpecies> <species id="M_0001_c" name="A_c" compartment="C_0001" initialAmount="0" boundaryCondition="false"/> <species id="M_0002_b" name="E_e" compartment="C_0002" initialAmount="0" boundaryCondition="true"/> <species id="M_0003_e" name="C_e" compartment="C_0002" initialAmount="0" boundaryCondition="false"/> <species id="M_0004_c" name="B_c" compartment="C_0001" initialAmount="0" boundaryCondition="false"/> </listOfSpecies> <listOfReactions> <reaction id="R_0001" name="R1" reversible="false"> <listOfReactants> <speciesReference species="M_0001_c" stoichiometry="1"/> </listOfReactants> <listOfProducts> <speciesReference species="M_0004_c" stoichiometry="3"/> </listOfProducts> <kineticLaw> <math xmlns="http://www.w3.org/1998/Math/MathML"> <ci> FLUX_VALUE </ci> </math> <listOfParameters> <parameter id="LOWER_BOUND" value="-100" units="mmol_per_gDW_per_hr"/> <parameter id="UPPER_BOUND" value="100" units="mmol_per_gDW_per_hr"/> <parameter id="OBJECTIVE_COEFFICIENT" value="0" units="dimensionless"/> <parameter id="FLUX_VALUE" value="0" units="mmol_per_gDW_per_hr"/> </listOfParameters> </kineticLaw> </reaction> <reaction id="R_0002" name="R2" reversible="false"> <listOfReactants> <speciesReference species="M_0003_e" stoichiometry="1"/> </listOfReactants> <listOfProducts> <speciesReference species="M_0004_c" stoichiometry="3"/> </listOfProducts> <kineticLaw> <math xmlns="http://www.w3.org/1998/Math/MathML"> <ci> FLUX_VALUE </ci> </math> <listOfParameters> <parameter id="LOWER_BOUND" value="-100" units="mmol_per_gDW_per_hr"/> <parameter id="UPPER_BOUND" value="100" units="mmol_per_gDW_per_hr"/> <parameter id="OBJECTIVE_COEFFICIENT" value="0" units="dimensionless"/> <parameter id="FLUX_VALUE" value="0" units="mmol_per_gDW_per_hr"/> </listOfParameters> </kineticLaw> </reaction> <reaction id="R_0003" name="R3" reversible="true"> <listOfReactants> <speciesReference species="M_0004_c" stoichiometry="1"/> <speciesReference species="M_0003_e" stoichiometry="1"/> </listOfReactants> <listOfProducts> <speciesReference species="M_0002_b" stoichiometry="1"/> </listOfProducts> <kineticLaw> <math xmlns="http://www.w3.org/1998/Math/MathML"> <ci> FLUX_VALUE </ci> </math> <listOfParameters> <parameter id="LOWER_BOUND" value="-100" units="mmol_per_gDW_per_hr"/> <parameter id="UPPER_BOUND" value="100" units="mmol_per_gDW_per_hr"/> <parameter id="OBJECTIVE_COEFFICIENT" value="0" units="dimensionless"/> <parameter id="FLUX_VALUE" value="0" units="mmol_per_gDW_per_hr"/> </listOfParameters> </kineticLaw> </reaction> </listOfReactions> </model> </sbml> """ exp_export = sbml_export # TODO: we have a stochioustic processes in metabolite id generation so strings can't be used to assert self.assertEquals(exp_export, sbml_export)
def toSBMLString(net): try: m = libsbml.Model(net.id) except NotImplementedError: m = libsbml.Model(sbml_level, sbml_version) m.setId(net.id) m.setName(net.name) for id, fd in net.functionDefinitions.items(): try: sfd = libsbml.FunctionDefinition(id) except: sfd = libsbml.FunctionDefinition(sbml_level, sbml_version) sfd.setId(id) sfd.setName(fd.name) formula = fd.math formula = formula.replace('**', '^') formula = 'lambda(%s, %s)' % (','.join(fd.variables), formula) sfd.setMath(libsbml.parseFormula(formula)) m.addFunctionDefinition(sfd) for id, c in net.compartments.items(): try: sc = libsbml.Compartment(id) except NotImplementedError: sc = libsbml.Compartment(sbml_level, sbml_version) sc.setId(id) sc.setName(c.name) sc.setConstant(c.is_constant) sc.setSize(c.initialValue) m.addCompartment(sc) for id, s in net.species.items(): try: ss = libsbml.Species(id) except NotImplementedError: ss = libsbml.Species(sbml_level, sbml_version) ss.setId(id) ss.setName(s.name) ss.setCompartment(s.compartment) if s.initialValue is not None and not isinstance(s.initialValue, str): ss.setInitialConcentration(s.initialValue) ss.setBoundaryCondition(s.is_boundary_condition) m.addSpecies(ss) for id, p in net.parameters.items(): try: sp = libsbml.Parameter(id) except NotImplementedError: sp = libsbml.Parameter(sbml_level, sbml_version) sp.setId(id) sp.setName(p.name) if p.initialValue is not None: sp.setValue(p.initialValue) sp.setConstant(p.is_constant) m.addParameter(sp) for id, r in net.rateRules.items(): try: sr = libsbml.RateRule() except NotImplementedError: sr = libsbml.RateRule(sbml_level, sbml_version) sr.setVariable(id) formula = r.replace('**', '^') sr.setMath(libsbml.parseFormula(formula)) m.addRule(sr) for id, r in net.assignmentRules.items(): try: sr = libsbml.AssignmentRule() except NotImplementedError: sr = libsbml.AssignmentRule(sbml_level, sbml_version) sr.setVariable(id) formula = r.replace('**', '^') sr.setMath(libsbml.parseFormula(formula)) m.addRule(sr) for r, r in net.algebraicRules.items(): try: sr = libsbml.AlgebraicRule() except NotImplementedError: sr = libsbml.AlgebraicRule(sbml_level, sbml_version) formula = r.replace('**', '^') sr.setMath(libsbml.parseFormula(formula)) m.addRule(sr) for id, rxn in net.reactions.items(): try: srxn = libsbml.Reaction(id) except NotImplementedError: srxn = libsbml.Reaction(sbml_level, sbml_version) srxn.setId(id) srxn.setName(rxn.name) # Handle the case where the model was originally read in from an # SBML file, so that the reactants and products of the Reaction # object are explicitly set. if rxn.reactant_stoichiometry != None and \ rxn.product_stoichiometry != None: for rid, stoich_list in rxn.reactant_stoichiometry.items(): for stoich in stoich_list: rxn_add_stoich(srxn, rid, -stoich, is_product=False) for rid, stoich_list in rxn.product_stoichiometry.items(): for stoich in stoich_list: rxn_add_stoich(srxn, rid, stoich, is_product=True) # Handle the case where the model was created using the SloppyCell # API, in which case reactants and products are inferred from their # stoichiometries else: for rid, stoich in rxn.stoichiometry.items(): rxn_add_stoich(srxn, rid, stoich) formula = rxn.kineticLaw.replace('**', '^') try: kl = libsbml.KineticLaw(formula) except NotImplementedError: kl = libsbml.KineticLaw(sbml_level, sbml_version) kl.setFormula(formula) srxn.setKineticLaw(kl) m.addReaction(srxn) for id, e in net.events.items(): try: se = libsbml.Event(id) except NotImplementedError: se = libsbml.Event(sbml_level, sbml_version) se.setId(id) se.setName(e.name) formula = e.trigger.replace('**', '^') formula = formula.replace('and_func(', 'and(') formula = formula.replace('or_func(', 'or(') ast = libsbml.parseFormula(formula) if ast is None: raise ValueError('Problem parsing event trigger: %s. Problem may ' 'be use of relational operators (< and >) rather ' 'than libsbml-friendly functions lt and gt.' % formula) try: se.setTrigger(ast) except TypeError: try: trigger = libsbml.Trigger(ast) except NotImplementedError: trigger = libsbml.Trigger(sbml_level, sbml_version) trigger.setMath(ast) se.setTrigger(trigger) formula = str(e.delay).replace('**', '^') try: se.setDelay(libsbml.parseFormula(formula)) except TypeError: try: se.setDelay(libsbml.Delay(libsbml.parseFormula(formula))) except NotImplementedError: delay = libsbml.Delay(sbml_level, sbml_version) delay.setMath(libsbml.parseFormula(formula)) se.setDelay(delay) for varId, formula in e.event_assignments.items(): try: sea = libsbml.EventAssignment() except NotImplementedError: sea = libsbml.EventAssignment(sbml_level, sbml_version) sea.setVariable(varId) formula = str(formula).replace('**', '^') formula = formula.replace('and_func(', 'and(') formula = formula.replace('or_func(', 'or(') ast = libsbml.parseFormula(formula) replaceTime(ast) sea.setMath(ast) se.addEventAssignment(sea) m.addEvent(se) for id, con in net.constraints.items(): try: scon = libsbml.Constraint() except NotImplementedError: scon = libsbml.Constraint(sbml_level, sbml_version) scon.setId(con.id) scon.setName(con.name) formula = con.trigger.replace('**', '^') ast = libsbml.parseFormula(formula) if ast is None: raise ValueError('Problem parsing constraint math: %s. Problem may ' 'be use of relational operators (< and >) rather ' 'than libsbml-friendly functions lt and gt.' % formula) #try: scon.setMath(ast) #except TypeError: # scon.setMath(libsbml.Trigger(ast)) m.addConstraint(scon) d = libsbml.SBMLDocument(sbml_level, sbml_version) d.setModel(m) sbmlStr = libsbml.writeSBMLToString(d) return sbmlStr
""" Try to set SBOTerm on reaction. """ import libsbml # using L3V2, so I don't need species on reaction doc = libsbml.SBMLDocument(3, 1) model = doc.createModel() model.setId('test model') r = model.createReaction() r.setSBOTerm('SBO:0000631') sbml_str = libsbml.writeSBMLToString(doc) print(sbml_str)
def getSbml(self): ''' Returns SBML representation of model ''' import libsbml return libsbml.writeSBMLToString(self.document)