def test_species_concentration_units(self): model = Model() st_1 = model.species_types.create(id='st_1') st_2 = model.species_types.create(id='st_2') c_1 = model.compartments.create(id='c_1') c_2 = model.compartments.create(id='c_2') st_1_c_1 = model.species.create(species_type=st_1, compartment=c_1) st_1_c_2 = model.species.create(species_type=st_1, compartment=c_2) st_2_c_1 = model.species.create(species_type=st_2, compartment=c_1) st_2_c_2 = model.species.create(species_type=st_2, compartment=c_2) st_1_c_1.id = st_1_c_1.gen_id() st_1_c_2.id = st_1_c_2.gen_id() st_2_c_1.id = st_2_c_1.gen_id() st_2_c_2.id = st_2_c_2.gen_id() st_1_c_1.distribution_init_concentration = DistributionInitConcentration(units=unit_registry.parse_units('gram')) st_1_c_2.distribution_init_concentration = DistributionInitConcentration(units=unit_registry.parse_units('hour')) st_2_c_1.distribution_init_concentration = DistributionInitConcentration(units=unit_registry.parse_units('liter')) st_2_c_2.distribution_init_concentration = DistributionInitConcentration(units=unit_registry.parse_units('second')) st_1_c_1.distribution_init_concentration.id = st_1_c_1.distribution_init_concentration.gen_id() st_1_c_2.distribution_init_concentration.id = st_1_c_2.distribution_init_concentration.gen_id() st_2_c_1.distribution_init_concentration.id = st_2_c_1.distribution_init_concentration.gen_id() st_2_c_2.distribution_init_concentration.id = st_2_c_2.distribution_init_concentration.gen_id() ChangeValueTransform((('species', {'id': 'st_1[c_1]'}), 'distribution_init_concentration', 'units'), unit_registry.parse_units('meter')).run(model) self.assertEqual(st_1_c_1.distribution_init_concentration.units, unit_registry.parse_units('meter')) self.assertEqual(st_1_c_2.distribution_init_concentration.units, unit_registry.parse_units('hour')) self.assertEqual(st_2_c_1.distribution_init_concentration.units, unit_registry.parse_units('liter')) self.assertEqual(st_2_c_2.distribution_init_concentration.units, unit_registry.parse_units('second'))
def gen_distribution_init_concentrations(self): """ Generate concentrations in model from knowledge base """ kb = self.knowledge_base model = self.model cytosol = model.compartments.get_one(id='c') Avogadro = model.parameters.get_one(id='Avogadro') for conc in kb.cell.concentrations: species_comp_model = model.compartments.get_one( id=conc.species.compartment.id) species_type = model.species_types.get_or_create( id=conc.species.species_type.id) species = model.species.get_or_create( species_type=species_type, compartment=species_comp_model) species.id = species.gen_id() if conc.units == unit_registry.parse_units('molecule'): mean_concentration = conc.value elif conc.units == unit_registry.parse_units('M'): mean_concentration = conc.value * Avogadro.value * species_comp_model.init_volume.mean else: raise Exception('Unsupported units: {}'.format( conc.units.name)) conc = model.distribution_init_concentrations.create( species=species, mean=mean_concentration, units=unit_registry.parse_units('molecule'), comments=conc.comments) conc.id = conc.gen_id()
def test_SbmlExporter_error(self): model = Model(id='model') model.submodels.create( id='Metabolism', framework=onto['WC:dynamic_flux_balance_analysis']) model.submodels.create( id='Metabolism_2', framework=onto['WC:dynamic_flux_balance_analysis']) with self.assertRaisesRegex(ValueError, 'Only 1 submodel can be encoded'): sbml_io.SbmlExporter.run(model) model = Model(id='model') submodel = model.submodels.create( id='Metabolism', framework=onto['WC:dynamic_flux_balance_analysis']) model.reactions.create( id='rxn_1', submodel=submodel, flux_bounds=FluxBounds(units=unit_registry.parse_units('M s^-1'))) model.reactions.create( id='rxn_1', submodel=submodel, flux_bounds=FluxBounds(units=unit_registry.parse_units('M s^-1'))) with self.assertRaisesRegex(sbml_util.LibSbmlError, 'Document is invalid'): with self.assertWarnsRegex(WcLangWarning, 'Model is invalid'): sbml_io.SbmlExporter.run(model)
def gen_parameters(self): """ Generate parameters for the model from knowledge base """ kb = self.knowledge_base model = self.model Avogadro = model.parameters.create(id='Avogadro', type = None, value = scipy.constants.Avogadro, units = unit_registry.parse_units('molecule mol^-1')) # Create parameters from kb for param in kb.cell.parameters: model_param = model.parameters.create( id=param.id, name=param.name, value=param.value, units=param.units) if 'K_m' in param.id: model_param.type = wc_ontology['WC:K_m'] elif 'k_cat' in param.id: model_param.type = wc_ontology['WC:k_cat'] model_param.units = unit_registry.parse_units('molecule^-1 s^-1') else: model_param.type = None if param.references: for ref in param.references: ref_model = model.references.get_or_create( __type=wc_lang.Reference, author=ref.authors, title=ref.title, publication=ref.journal, volume=ref.volume, issue=ref.issue, pages=ref.pages, year=ref.year, comments=ref.comments, type=wc_ontology['WC:article']) if not ref_model.id: ref_model.id = 'ref_'+str(len(model.references)) model_param.references.append(ref_model) if param.identifiers: for identifier in param.identifiers: identifier_model = wc_lang.Identifier( namespace=identifier.namespace, id=identifier.id) model_param.identifiers.append(identifier_model) # Standardize the units of doubling time if model.parameters.get_one(id='mean_doubling_time'): model_doubling_time = model.parameters.get_one(id='mean_doubling_time') else: raise ValueError('The cell object does not have the parameter mean_doubling_time') expr = unit_registry.parse_expression(str(model_doubling_time.units)) scale = expr.to(unit_registry.parse_units('second')) conversion_factor = scale.magnitude model_doubling_time.value *= conversion_factor model_doubling_time.units = unit_registry.parse_units('s')
def test_parameter_units(self): model = Model() p_1 = model.parameters.create(id='p_1', units=unit_registry.parse_units('M')) p_2 = model.parameters.create(id='p_2', units=unit_registry.parse_units('l')) ChangeValueTransform((('parameters', {'id': 'p_1'}), 'units'), unit_registry.parse_units('m^2')).run(model) self.assertEqual(p_1.units, unit_registry.parse_units('m^2')) self.assertEqual(p_2.units, unit_registry.parse_units('l'))
def setUp(self): self.model = model = Model(id='test', version='0.1') c = model.compartments.create(id='comp') c.init_density = model.parameters.create(id='density_compartment_1', value=1100, units=unit_registry.parse_units('g l^-1')) t0 = model.species_types.create(id='s0', type=onto['WC:metabolite']) t1 = model.species_types.create(id='s1', type=onto['WC:metabolite']) t2 = model.species_types.create(id='s2', type=onto['WC:metabolite']) s0 = model.species.create(id='s0[comp]', species_type=t0, compartment=c) s1 = model.species.create(id='s1[comp]', species_type=t1, compartment=c) s2 = model.species.create(id='s2[comp]', species_type=t2, compartment=c) self.submodel = submodel = model.submodels.create(id='submodel', framework=onto['WC:stochastic_simulation_algorithm']) self.r0 = r0 = model.reactions.create(id='r0', reversible=True, submodel=submodel) r0.participants.create(species=s0, coefficient=-2) r0.participants.create(species=s1, coefficient=3) r0_f = r0.rate_laws.create(id='r0-forward', direction=RateLawDirection.forward, model=model) a = model.parameters.create(id='a', value=1., units=unit_registry.parse_units('s^-1')) r0_f.expression, error = RateLawExpression.deserialize('a', {Parameter: {'a': a}}) assert error is None, str(error) r0_b = r0.rate_laws.create(id='r0-backward', direction=RateLawDirection.backward, model=model) b = model.parameters.create(id='b', value=1., units=unit_registry.parse_units('s^-1')) r0_b.expression, error = RateLawExpression.deserialize('b', {Parameter: {'b': b}}) assert error is None, str(error) r0.references.create(id='ref_0', model=model) r0.identifiers.create(namespace='x', id='y') self.r1 = r1 = model.reactions.create(id='r1', reversible=False, submodel=submodel) r1.participants.create(species=s1, coefficient=-3) r1.participants.create(species=s2, coefficient=4) r1_f = r1.rate_laws.create(id='r1-forward', direction=RateLawDirection.forward, model=model) c = model.parameters.create(id='c', value=1., units=unit_registry.parse_units('s^-1')) r1_f.expression, error = RateLawExpression.deserialize('c', {Parameter: {'c': c}}) assert error is None, str(error) r1.references.create(id='ref_1', model=model) r1.identifiers.create(namespace='xx', id='yy') self.tempdir = tempfile.mkdtemp() # check model's integrity by writing and reading with validate=True filename = os.path.join(self.tempdir, 'model_for_tranformation.xlsx') Writer().run(filename, model, data_repo_metadata=False) # turn off validate_element_charge_balance validation so that simple species and reactions validate with EnvironUtils.temp_config_env([(['wc_lang', 'validation', 'validate_element_charge_balance'], 'False')]): model_read = Reader().run(filename, validate=True)[Model][0] self.assertTrue(model_read.is_equal(model))
def gen_compartments(self): # Create default compartments kb = self.knowledge_base model = self.model # TODO: get volume from KB, talk to YH c_init_volume = wc_lang.core.InitVolume( distribution=wc_ontology['WC:normal_distribution'], mean=1E-15, std=0) c = model.compartments.get_or_create(id='c', name='Cytosol', init_volume=c_init_volume) c.init_density = model.parameters.create( id='density_c', value=1100., units=unit_registry.parse_units('g l^-1')) volume_c = model.functions.create(id='volume_c', units=unit_registry.parse_units('l')) volume_c.expression, error = wc_lang.FunctionExpression.deserialize( f'{c.id} / {c.init_density.id}', { wc_lang.Compartment: { c.id: c }, wc_lang.Parameter: { c.init_density.id: c.init_density }, }) assert error is None, str(error) # Extracellular space e_init_volume = wc_lang.core.InitVolume( distribution=wc_ontology['WC:normal_distribution'], mean=1E-10, std=0) e = model.compartments.get_or_create(id='e', name='Extracellular space', init_volume=e_init_volume) e.init_density = model.parameters.create( id='density_e', value=1000., units=unit_registry.parse_units('g l^-1')) volume_e = model.functions.create(id='volume_e', units=unit_registry.parse_units('l')) volume_e.expression, error = wc_lang.FunctionExpression.deserialize( f'{e.id} / {e.init_density.id}', { wc_lang.Compartment: { e.id: e }, wc_lang.Parameter: { e.init_density.id: e.init_density }, }) assert error is None, str(error)
def test_create_parameter(self): self.per_second_id = 'unit_1_per_second' self.per_second = LibSbmlInterface.call_libsbml( self.sbml_model.createUnitDefinition) LibSbmlInterface.call_libsbml(self.per_second.setIdAttribute, self.per_second_id) LibSbmlInterface.create_base_unit('unit_1_per_second', self.per_second, 'second', exponent=-1) id = 'id1' name = 'name1' value = 13.0 constant = False parameter = LibSbmlInterface.create_parameter( self.sbml_model, id, value, unit_registry.parse_units('dimensionless'), name=name, constant=constant) self.assertTrue( LibSbmlInterface.call_libsbml(parameter.hasRequiredAttributes)) self.assertEqual( LibSbmlInterface.call_libsbml(parameter.getIdAttribute), id) self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getName), name) self.assertTrue(LibSbmlInterface.call_libsbml(parameter.isSetValue)) self.assertTrue(LibSbmlInterface.call_libsbml(parameter.isSetUnits)) self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getValue), value) self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getConstant), constant) # test defaults id = 'id2' parameter = LibSbmlInterface.create_parameter( self.sbml_model, id, value, unit_registry.parse_units('dimensionless')) self.assertEqual( LibSbmlInterface.call_libsbml(parameter.getIdAttribute), id) self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getName), '') self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getConstant), True) # test units id = 'id3' parameter = LibSbmlInterface.create_parameter( self.sbml_model, id, value, unit_registry.parse_units('s^-1')) self.assertTrue( LibSbmlInterface.call_libsbml(parameter.hasRequiredAttributes)) self.assertTrue(LibSbmlInterface.call_libsbml(parameter.isSetUnits)) self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getUnits), self.per_second_id)
def test_gen_unit_id(self): self.assertEqual( LibSbmlInterface.gen_unit_id( unit_registry.parse_units('meter / second')), 'unit_meter_per_second') self.assertEqual( LibSbmlInterface.gen_unit_id(unit_registry.parse_units('second')), 'second') with self.assertRaisesRegex(ValueError, 'Cannot generate SBML id'): LibSbmlInterface.gen_unit_id(None)
def gen_submodel_0(): timestamp = datetime.datetime(2018, 1, 1, 12, 0, 0) model = Model(id='model', version='0.0.1', wc_lang_version='0.0.2', created=timestamp, updated=timestamp) submodel_0 = model.submodels.create(id='submodel_0') model.compartments.create(id='c_0') structure = ChemicalStructure(charge=0) model.species_types.create(id='s_0', structure=structure) model.species_types.create(id='s_1', structure=structure) model.species.create(compartment=model.compartments[0], species_type=model.species_types[0]) model.species.create(compartment=model.compartments[0], species_type=model.species_types[1]) for species in model.species: species.id = species.gen_id() model.reactions.create(id='rxn_00', submodel=submodel_0) model.reactions.create(id='rxn_01', submodel=submodel_0) model.reactions[0].participants.create(species=model.species[0], coefficient=-1) model.reactions[0].participants.create(species=model.species[1], coefficient=1) model.reactions[1].participants.add(model.reactions[0].participants[0]) model.parameters.create(id='p_0', value=1., units=unit_registry.parse_units('molecule')) model.parameters.create(id='p_1', value=1., units=unit_registry.parse_units('molecule')) model.parameters.create(id='p_3', value=1., units=unit_registry.parse_units('g l^-1')) model.compartments[0].init_density = model.parameters[2] model.parameters.create(id='p_5', value=1., units=unit_registry.parse_units('s^-1')) model.parameters.create(id='p_6', value=1., units=unit_registry.parse_units('s^-1')) rl = model.rate_laws.create(reaction=model.reactions[0]) rl.expression, error = RateLawExpression.deserialize(f'{model.parameters[3].id}', {Parameter: {model.parameters[3].id: model.parameters[3]}}) rl = model.rate_laws.create(reaction=model.reactions[1]) rl.expression, error = RateLawExpression.deserialize(f'{model.parameters[4].id}', {Parameter: {model.parameters[4].id: model.parameters[4]}}) for rl in model.rate_laws: rl.id = rl.gen_id() objs = { Species: {s.id: s for s in model.species}, Parameter: {p.id: p for p in model.parameters}, } model.stop_conditions.create(id='sc_0') model.stop_conditions.create(id='sc_1') model.stop_conditions[0].expression, error = StopConditionExpression.deserialize( f'{model.species[0].id} > {model.parameters[0].id}', objs) assert error is None, str(error) model.stop_conditions[1].expression, error = StopConditionExpression.deserialize( f'{model.species[1].id} > {model.parameters[1].id}', objs) assert error is None, str(error) model.references.create(id='ref_0', submodels=[submodel_0]) model.references.create(id='ref_1', submodels=[submodel_0]) return model
def simple_activator(model, reaction_id, activator): """ Generate the parameters and string expression of the regulation factor derived in Bintu et al (2005) for the case of a simple activator Args: model (:obj:`wc_lang.Model`): model reaction_id (:obj:`str`): reaction id activator (:obj:`wc_lang.Species`): activator Returns: :obj:`str`: string expression of the regulation factor :obj:`dict` of :obj:`wc_lang.Species`: dict of species in the expression with the species ids as keys and the species objects as values :obj:`dict` of :obj:`wc_lang.Parameter`: dict of parameters in the expression with the parameter ids as keys and the parameter objects as values :obj:`dict` of :obj:`wc_lang.Function`: dict of functions in the expression with the function ids as keys and the function objects as values """ species = {} parameters = {} functions = {} species[activator.id] = activator avogadro = model.parameters.get_or_create( id='Avogadro', type=None, value=scipy.constants.Avogadro, units=unit_registry.parse_units('molecule mol^-1')) parameters[avogadro.id] = avogadro Ka = model.parameters.get_or_create(id='Ka_{}_{}'.format( reaction_id, activator.species_type.id), type=None, units=unit_registry.parse_units('M')) parameters[Ka.id] = Ka f = model.parameters.get_or_create(id='f_{}_{}'.format( reaction_id, activator.species_type.id), type=None, units=unit_registry.parse_units('')) parameters[f.id] = f volume = activator.compartment.init_density.function_expressions[ 0].function functions[volume.id] = volume F_act = '((1 + {} / ({} * {} * {}) * {}) / (1 + {} / ({} * {} * {})))'.format( activator.id, Ka.id, avogadro.id, volume.id, f.id, activator.id, Ka.id, avogadro.id, volume.id) return F_act, species, parameters, functions
def normalize_unit_kind(self): self.assertEqual( LibSbmlInterface.normalize_unit_kind( unit_registry.parse_units('meter')), 'metre') self.assertEqual( LibSbmlInterface.normalize_unit_kind( unit_registry.parse_units('liter')), 'litre') self.assertEqual( LibSbmlInterface.normalize_unit_kind( unit_registry.parse_units('mole')), 'mole') self.assertEqual( LibSbmlInterface.normalize_unit_kind( unit_registry.parse_units('item')), 'item')
def gen_compartments(self): """ Generate compartments for the model from knowledge base """ kb = self.knowledge_base model = self.model if kb.cell.parameters.get_one(id='cell_volume'): mean_cell_volume = kb.cell.parameters.get_one(id='cell_volume').value else: raise ValueError('The cell object does not have the parameter cell_volume') culture_volume = self.options['culture_volume'] cell_density = self.options['cell_density'] membrane_density = self.options['membrane_density'] for comp in kb.cell.compartments: c = model.compartments.get_or_create( id=comp.id, name=comp.name) c.init_density = model.parameters.create( id='density_' + c.id, units=unit_registry.parse_units('g l^-1')) if comp.id=='e': c.biological_type = wc_ontology['WC:extracellular_compartment'] c.init_density.value = 1000. c.init_volume = wc_lang.core.InitVolume(distribution=wc_ontology['WC:normal_distribution'], mean=culture_volume, std=0) elif '_m' in comp.id: c.physical_type = wc_ontology['WC:membrane_compartment'] c.init_density.value = membrane_density organelle_fraction = kb.cell.compartments.get_one(id=comp.id[:comp.id.index('_')]).volumetric_fraction c.init_volume = wc_lang.core.InitVolume(distribution=wc_ontology['WC:normal_distribution'], mean=4.836E-09*(mean_cell_volume*organelle_fraction)**(2/3), std=0) else: c.init_density.value = cell_density organelle_fraction = kb.cell.compartments.get_one(id=comp.id).volumetric_fraction c.init_volume = wc_lang.core.InitVolume(distribution=wc_ontology['WC:normal_distribution'], mean=mean_cell_volume*organelle_fraction - 4.836E-09*(mean_cell_volume*organelle_fraction)**(2/3), std=0) volume = model.functions.create(id='volume_' + c.id, units=unit_registry.parse_units('l')) volume.expression, error = wc_lang.FunctionExpression.deserialize(f'{c.id} / {c.init_density.id}', { wc_lang.Compartment: {c.id: c}, wc_lang.Parameter: {c.init_density.id: c.init_density}, }) assert error is None, str(error)
def setUp(self): # make a Compartment & use it to make a DynamicCompartment comp_id = 'comp_id' self.mean_init_volume = 1E-17 self.compartment = Compartment(id=comp_id, name='name', init_volume=InitVolume( mean=self.mean_init_volume, std=self.mean_init_volume / 40.)) self.compartment.init_density = Parameter( id='density_{}'.format(comp_id), value=1100., units=unit_registry.parse_units('g l^-1')) self.random_state = RandomStateManager.instance() self.dynamic_compartment = DynamicCompartment(None, self.random_state, self.compartment) self.abstract_compartment = Compartment( id=comp_id, name='name', init_volume=InitVolume(mean=self.mean_init_volume, std=0), physical_type=onto['WC:abstract_compartment']) self.abstract_dynamic_compartment = DynamicCompartment( None, self.random_state, self.abstract_compartment)
def gen_parameters(self): kb = self.knowledge_base model = self.model # Create parameters #model.parameters.get_or_create(id='mean_doubling_time', # type=None, # value=kb.cell.parameters.get_one(id='mean_doubling_time').value, # units=unit_registry.parse_units('s')) Avogadro = model.parameters.create( id='Avogadro', type=None, value=scipy.constants.Avogadro, units=unit_registry.parse_units('molecule mol^-1')) for param in kb.cell.parameters: model_param = model.parameters.create(id=param.id, value=param.value, units=param.units) if 'K_m' in param.id: model_param.type = wc_ontology['WC:K_m'] elif 'k_cat' in param.id: model_param.type = wc_ontology['WC:k_cat'] else: model_param.type = None
def calibrate_submodel(self): """ Calibrate the submodel using data in the KB """ model = self.model beta = self.options.get('beta') Avogadro = model.parameters.get_or_create( id='Avogadro', type=None, value=scipy.constants.Avogadro, units=unit_registry.parse_units('molecule mol^-1')) cytosol = model.compartments.get_one(id='c') mean_doubling_time = self.knowledge_base.cell.parameters.get_one( id='mean_doubling_time').value init_species_counts = {} modifier = model.observables.get_one(id='rna_polymerase_obs') for species in modifier.expression.species: init_species_counts[species.gen_id( )] = species.distribution_init_concentration.mean rnas_kb = self.knowledge_base.cell.species_types.get( __type=wc_kb.prokaryote.RnaSpeciesType) for rna_kb, reaction in zip(rnas_kb, self.submodel.reactions): rna_product = model.species_types.get_one( id=rna_kb.id).species.get_one(compartment=cytosol) half_life = rna_kb.properties.get_one( property='half_life').get_value() mean_concentration = rna_product.distribution_init_concentration.mean average_rate = utils.calc_avg_syn_rate(mean_concentration, half_life, mean_doubling_time) for species in reaction.get_reactants(): init_species_counts[species.gen_id( )] = species.distribution_init_concentration.mean if model.parameters.get(id='K_m_{}_{}'.format( reaction.id, species.species_type.id)): model_Km = model.parameters.get_one(id='K_m_{}_{}'.format( reaction.id, species.species_type.id)) model_Km.value = beta * species.distribution_init_concentration.mean \ / Avogadro.value / species.compartment.init_volume.mean model_kcat = model.parameters.get_one( id='k_cat_{}'.format(reaction.id)) model_kcat.value = 1. model_kcat.value = average_rate / reaction.rate_laws[ 0].expression._parsed_expression.eval({ wc_lang.Species: init_species_counts, wc_lang.Compartment: { cytosol.id: cytosol.init_volume.mean * cytosol.init_density.value }, })
def test_write_parameter(self): model = Model(id='model', version='0.0.1', wc_lang_version='0.0.1') submodel = model.submodels.create(id='submodel') species_type = model.species_types.create(id='st', structure=ChemicalStructure( molecular_weight=1., charge=0)) compartment = model.compartments.create(id='c') species = model.species.create(species_type=species_type, compartment=compartment) species.id = species.gen_id() reaction = submodel.reactions.create(id='reaction', model=model) reaction.participants.create(species=species, coefficient=1.) rate_law = reaction.rate_laws.create( model=model, direction=RateLawDirection.forward) rate_law.id = rate_law.gen_id() rate_law_eq = rate_law.expression = RateLawExpression( expression='parameter') parameter = rate_law_eq.parameters.create( id='parameter', value=1., units=unit_registry.parse_units('dimensionless'), model=model) filename = os.path.join(self.tempdir, 'model.xlsx') Writer().run(filename, model, data_repo_metadata=False) parameter.model = Model(id='model2', version='0.0.1', wc_lang_version='0.0.1') with self.assertRaisesRegex(ValueError, 'must be set to the instance of `Model`'): Writer().run(filename, model, data_repo_metadata=False)
def test_concentrations(self): cytosol = self.model.compartments.get_one(id='c') for conc in self.kb.cell.concentrations: model_species_type = self.model.species_types.get_one(id=conc.species.species_type.id) model_specie = model_species_type.species.get_one(compartment=cytosol) self.assertIsInstance(model_species_type, wc_lang.SpeciesType) self.assertIsInstance(model_specie, wc_lang.Species) self.assertTrue(conc.units, unit_registry.parse_units('M'))
def parse_unit_id(cls, sbml_unit_def_id): """ Parse a unit from an SBML unit definition. Args: sbml_unit_def_id (:obj:`str`): id of SBML unit definition Returns: :obj:`unit_registry.Unit`: units """ if sbml_unit_def_id.startswith('unit_'): return unit_registry.parse_units( sbml_unit_def_id.partition('unit_')[2].replace( '_per_', ' / ').replace('_times_', ' * ').replace('_pow_', ' ** ')) else: if sbml_unit_def_id == 'mole': return unit_registry.parse_units('molecule') return unit_registry.parse_units(sbml_unit_def_id)
def test_generator(self): kb = wc_kb.KnowledgeBase() cell = kb.cell = wc_kb.Cell() cell.taxon = 9606 cell.parameters.create(id='cell_volume', value=1E-15) cell.parameters.create(id='mean_doubling_time', value=20., units=unit_registry.parse_units('hour')) compartments = {'c': 0.7, 'n': 0.3, 'e': None} for k, v in compartments.items(): cell.compartments.create(id=k, volumetric_fraction=v) test_component_generators = [initialize_model.InitializeModel] gen = core.EukaryoteModelGenerator( kb, component_generators=test_component_generators, options={ 'id': 'h1_test', 'name': 'h1 model', 'version': '2.3.1', 'component': { 'InitializeModel': { 'cell_density': 1100., 'gen_dna': False, 'gen_pre_rnas': False, 'gen_transcripts': False, 'gen_protein': False, 'gen_metabolites': False, 'gen_complexes': False, 'gen_distribution_init_concentrations': False, 'gen_observables': False, 'gen_kb_reactions': False, 'gen_kb_rate_laws': False, } } }) model = gen.run() self.assertEqual(model.id, 'h1_test') self.assertEqual(model.name, 'h1 model') self.assertEqual(model.version, '2.3.1') self.assertEqual( model.parameters.get_one(id='mean_doubling_time').value, 72000) self.assertEqual(model.parameters.get_one(id='density_n').value, 1100) self.assertEqual(model.parameters.get_one(id='density_e').value, 1000) self.assertEqual( model.compartments.get_one(id='n').init_volume.mean, 2.997832792664565e-16) self.assertEqual( model.compartments.get_one(id='e').init_volume.mean, 1.0)
def gen_core_model(extra_species=True): timestamp = datetime.datetime(2018, 1, 1, 12, 0, 0) model = Model(id='model', version='0.0.1', wc_lang_version='0.0.2', created=timestamp, updated=timestamp) model.compartments.create(id='c_0') model.compartments.create(id='c_1') structure = ChemicalStructure(charge=0) model.species_types.create(id='s_0', structure=structure) model.species_types.create(id='s_1', structure=structure) model.species.create(compartment=model.compartments[0], species_type=model.species_types[0]) model.species.create(compartment=model.compartments[0], species_type=model.species_types[1]) model.species.create(compartment=model.compartments[1], species_type=model.species_types[0]) if extra_species: model.species.create(compartment=model.compartments[1], species_type=model.species_types[1]) for species in model.species: species.id = species.gen_id() model.parameters.create(id='p_0', value=1., units=unit_registry.parse_units('molecule')) model.parameters.create(id='p_1', value=1., units=unit_registry.parse_units('molecule')) model.parameters.create(id='p_2', value=1., units=unit_registry.parse_units('molecule')) model.parameters.create(id='p_3', value=1., units=unit_registry.parse_units('g l^-1')) model.parameters.create(id='p_4', value=1., units=unit_registry.parse_units('g l^-1')) model.compartments[0].init_density = model.parameters[3] model.compartments[1].init_density = model.parameters[4] objs = { Species: {s.id: s for s in model.species}, Parameter: {p.id: p for p in model.parameters}, } model.stop_conditions.create(id='sc_0') model.stop_conditions.create(id='sc_1') model.stop_conditions.create(id='sc_2') model.stop_conditions[0].expression, error = StopConditionExpression.deserialize( f'{model.species[0].id} > {model.parameters[0].id}', objs) assert error is None, str(error) model.stop_conditions[1].expression, error = StopConditionExpression.deserialize( f'{model.species[1].id} > {model.parameters[1].id}', objs) assert error is None, str(error) model.stop_conditions[2].expression, error = StopConditionExpression.deserialize( f'{model.species[2].id} > {model.parameters[2].id}', objs) assert error is None, str(error) return model
def specify_init_accounted_fraction(self, desired_init_accounted_fraction): # make a DynamicCompartment with accounted_fraction ~= desired_init_accounted_fraction # without changing init_accounted_mass or init_volume init_density = self.dynamic_compartment.init_accounted_mass / \ (desired_init_accounted_fraction * self.dynamic_compartment.init_volume) self.compartment.init_density = Parameter( id='density_x', value=init_density, units=unit_registry.parse_units('g l^-1')) return DynamicCompartment(None, self.random_state, self.compartment)
def gen_components(self): """ Construct knowledge base components """ # get options options = self.options # generate properties cell = self.knowledge_base.cell prop = cell.properties.get_or_create(id='mean_volume') prop.value = options.get('mean_volume') prop.units = unit_registry.parse_units('l') prop = cell.properties.get_or_create(id='mean_doubling_time') prop.value = options.get('mean_doubling_time') prop.units = unit_registry.parse_units('s') prop = cell.properties.get_or_create(id='mean_cell_density') prop.value = options.get('mean_cell_density') prop.units = unit_registry.parse_units('cells l^-1')
def test_parse_parameter(self): units = unit_registry.parse_units('s^-1') LibSbmlInterface.create_unit(units, self.sbml_model) parameter = LibSbmlInterface.create_parameter(self.sbml_model, 'parameter_1', 1.5, units) id, name, value, units = LibSbmlInterface.parse_parameter(parameter) self.assertEqual(id, 'parameter_1') self.assertEqual(name, '') self.assertEqual(value, 1.5) self.assertEqual(units, unit_registry.parse_expression('s^-1'))
def test_validate_exception(self): model = Model(id='model', name='test model', version='0.0.1a', wc_lang_version='0.0.1') model.parameters.append( Parameter(id='param_1', value=1., units=unit_registry.parse_units('dimensionless'))) model.parameters.append( Parameter(id='param_1', value=1., units=unit_registry.parse_units('dimensionless'))) self.assertNotEqual(Validator().run(model, get_related=True), None) filename = path.join(self.tempdir, 'model.xlsx') Writer().run(filename, model, data_repo_metadata=False) with self.assertRaisesRegex(SystemExit, '^Model is invalid: '): with __main__.App(argv=['validate', filename]) as app: app.run()
def test_simple_activator(self): model = wc_lang.Model() init_volume = wc_lang.core.InitVolume( distribution=wc_ontology['WC:normal_distribution'], mean=0.5, std=0) c = wc_lang.Compartment(id='c', init_volume=init_volume) c.init_density = wc_lang.Parameter(id='density_' + c.id, value=1.) volume = wc_lang.Function(id='volume_' + c.id) volume.expression, error = wc_lang.FunctionExpression.deserialize( f'{c.id} / {c.init_density.id}', { wc_lang.Compartment: { c.id: c }, wc_lang.Parameter: { c.init_density.id: c.init_density }, }) assert error is None, str(error) tf_species_type = wc_lang.SpeciesType(id='Activator') tf_species = wc_lang.Species(species_type=tf_species_type, compartment=c) tf_species.id = tf_species.gen_id() wc_lang.DistributionInitConcentration(species=tf_species, mean=0.5) F_act, species, parameters, functions = utils.simple_activator( model, 'transcription_rna1', tf_species) self.assertEqual( F_act, '((1 + Activator[c] / (Ka_transcription_rna1_Activator * Avogadro * volume_c) * f_transcription_rna1_Activator) / ' '(1 + Activator[c] / (Ka_transcription_rna1_Activator * Avogadro * volume_c)))' ) self.assertEqual(species, {'Activator[c]': tf_species}) self.assertEqual(functions, {'volume_c': volume}) self.assertEqual(set(model.parameters), set(parameters.values())) self.assertEqual( sorted(list(parameters.keys())), sorted([ 'Avogadro', 'f_transcription_rna1_Activator', 'Ka_transcription_rna1_Activator' ])) self.assertEqual( model.parameters.get_one( id='Ka_transcription_rna1_Activator').type, None) self.assertEqual( model.parameters.get_one( id='Ka_transcription_rna1_Activator').units, unit_registry.parse_units('M'))
def test_init_model(self): model = Model() model.parameters.create(units=unit_registry.parse_units('s^-1')) model.parameters.create(units=unit_registry.parse_units('g / l')) model.parameters.create(units=unit_registry.parse_units('m')) sbml_model = LibSbmlInterface.init_model(model, self.document, packages={'fbc': 2}) # check the SBML document LibSbmlInterface.verify_doc(self.document) return_val = LibSbmlInterface.call_libsbml( self.document.checkConsistency, returns_int=True) self.assertEqual(return_val, 0) LibSbmlInterface.verify_doc_is_compatible(self.document) # check seconds unit unit_def = LibSbmlInterface.call_libsbml(sbml_model.getUnitDefinition, 'unit_1_per_second') units = LibSbmlInterface.call_libsbml(UnitDefinition.printUnits, unit_def, True) self.assertEqual(units, '(1 second)^-1')
def test_get_obj_units(self): model = Model() units = set([model.time_units]) self.assertEqual(set(obj_tables.sci.units.get_obj_units(model)), units) model.compartments.create() model.compartments.create() for c in model.compartments: units.add(c.mass_units) if c.init_volume: units.add(c.init_volume.units) if c.ph: units.add(c.ph.units) self.assertEqual(set(obj_tables.sci.units.get_obj_units(model)), units) model.species_types.create() model.species_types.create() self.assertEqual(set(obj_tables.sci.units.get_obj_units(model)), units) for c in model.compartments: for s in model.species_types: model.species.create(compartment=c, species_type=s) for s in model.species: units.add(s.units) self.assertEqual(set(obj_tables.sci.units.get_obj_units(model)), units) model.distribution_init_concentrations.create( species=model.species[0], units=unit_registry.parse_units('M')) model.distribution_init_concentrations.create( species=model.species[1], units=unit_registry.parse_units('molecule')) for o in model.distribution_init_concentrations: units.add(o.units) self.assertEqual(set(obj_tables.sci.units.get_obj_units(model)), units) model.parameters.create(units=unit_registry.parse_units('g')) model.parameters.create(units=unit_registry.parse_units('l')) model.parameters.create(units=unit_registry.parse_units('s')) for p in model.parameters: units.add(p.units) self.assertEqual(set(obj_tables.sci.units.get_obj_units(model)), units) model.functions.create(units=unit_registry.parse_units('g / l')) model.functions.create(units=unit_registry.parse_units('g / s')) model.functions.create(units=unit_registry.parse_units('l / s')) for f in model.functions: units.add(f.units) self.assertEqual(set(obj_tables.sci.units.get_obj_units(model)), units)
def setup_submodel_params(self, model_type, num_species, vol_mean, vol_std): # make Model model = Model(id='test_model', name=model_type, version='0.0.0', wc_lang_version='0.0.1') # make SpeciesTypes species_types = [] for i in range(num_species): spec_type = model.species_types.create(id='spec_type_{}'.format(i)) species_types.append(spec_type) initial_volume = InitVolume(mean=vol_mean, std=vol_std, units=unit_registry.parse_units('l')) comp = model.compartments.create( id='compt_1', biological_type=onto['WC:cellular_compartment'], init_volume=initial_volume) comp.init_density = model.parameters.create( id='density_compt_1', value=1100, units=unit_registry.parse_units('g l^-1')) return (model, species_types, comp)
def test_dynamic_compartment_exceptions(self): compartment = Compartment(id='id', name='name', init_volume=InitVolume(mean=0)) with self.assertRaises(MultialgorithmError): DynamicCompartment(None, self.random_state, compartment) self.compartment.init_density = Parameter( id='density_{}'.format(self.compartment.id), value=float('nan'), units=unit_registry.parse_units('g l^-1')) with self.assertRaises(MultialgorithmError): DynamicCompartment(None, self.random_state, self.compartment) self.compartment.init_density = Parameter( id='density_{}'.format(self.compartment.id), value=0., units=unit_registry.parse_units('g l^-1')) with self.assertRaises(MultialgorithmError): DynamicCompartment(None, self.random_state, self.compartment) self.compartment.init_volume = None with self.assertRaises(MultialgorithmError): DynamicCompartment(None, self.random_state, self.compartment)