Exemple #1
0
    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 main(examples_dir=os.path.join(os.path.dirname(__file__), 'examples')):

    ################################################################
    # This code is used by literalinclude commands in wc_lang_tutorial.rst
    # It contains many separate examples, each prefixed by a comment that delineates the
    # start of the example and is used by a start-after option in a literalinclude.
    # The line before each of these comments is:
    # Don't change the next comment - it's used by a literalinclude
    # Changes to these comments should be synchronized with changes to wc_lang_tutorial.rst
    ################################################################

    # save the results of example commands so this function can be unit-tested
    results = []

    ################################################
    # Reading and writing models to/from files
    ################################################

    model_filename = os.path.join(examples_dir, 'example_model.xlsx')
    # Don't change the next comment - it's used by a literalinclude
    # This example illustrates how to read a model from an Excel file
    # 'model_filename' is the name of an Excel file storing a model
    model = wc_lang.io.Reader().run(model_filename)[wc_lang.Model][0]

    results.append("read model: '{}'".format(model.name))

    if not os.path.isdir(examples_dir):
        os.makedirs(examples_dir)
    # Don't change the next comment - it's used by a literalinclude
    # This example illustrates how to write a model to a set of .tsv files
    # 'examples_dir' is a directory
    model_filename_pattern = os.path.join(examples_dir, 'example_model-*.tsv')
    wc_lang.io.Writer().run(model_filename_pattern, model, data_repo_metadata=False)

    results.append("write a model to a set of .tsv files: '{}'".format(model_filename_pattern))

    # Don't change the next comment - it's used by a literalinclude
    # This example illustrates how to read a model from a set of .tsv files
    model_from_tsv = wc_lang.io.Reader().run(model_filename_pattern)[wc_lang.Model][0]

    results.append("read a model from a set of .tsv files: '{}'".format(model_from_tsv.name))

    ################################################
    # Accessing model properties
    ################################################

    # Don't change the next comment - it's used by a literalinclude
    # ``wc_lang`` models have many attributes
    model.id                # the model's unique identifier
    model.name              # its human readable name
    model.version           # its version number
    model.taxon             # the taxon of the organism being modeled
    model.submodels         # a list of the model's submodels
    model.compartments      # "  "   "  the model's compartments
    model.species_types     # "  "   "  its species types
    model.parameters        # "  "   "  its parameters
    model.references        # "  "   "  publication sources for the model instance
    model.identifiers       # "  "   "  identifiers in external namespaces for the model instance

    results.append("referenced model attributes")

    # Don't change the next comment - it's used by a literalinclude
    # ``wc_lang`` also provides many convenience methods
    model.get_compartments()
    model.get_species_types()
    model.get_submodels()
    model.get_species()
    model.get_distribution_init_concentrations()
    model.get_reactions()
    model.get_dfba_obj_reactions()
    model.get_rate_laws()
    model.get_parameters()
    model.get_references()

    results.append("referenced model convenience methods")

    # Don't change the next comment - it's used by a literalinclude
    # ``get_reactions()`` returns a list of all of the reactions in a model's submodels
    reaction_identification = []
    for reaction in model.get_reactions():
        reaction_identification.append('submodel name: {}, reaction id: {}'.format(
            reaction.submodel.name, reaction.id))

    results.append("get_reactions entry 0: '{}'".format(reaction_identification[0]))

    #################################################
    # Building models and editing model properties
    #################################################

    # Don't change the next comment - it's used by a literalinclude
    # The following illustrates how to program a trivial model
    # create a model with one submodel and one compartment
    prog_model = wc_lang.Model(id='programmatic_model', name='Programmatic model')

    submodel = wc_lang.Submodel(id='submodel_1', model=prog_model)

    cytosol = wc_lang.Compartment(id='c', name='Cytosol')

    # create 5 species types
    atp = wc_lang.SpeciesType(id='atp', name='ATP', model=prog_model)
    adp = wc_lang.SpeciesType(id='adp', name='ADP', model=prog_model)
    pi = wc_lang.SpeciesType(id='pi', name='Pi', model=prog_model)
    h2o = wc_lang.SpeciesType(id='h2o', name='H2O', model=prog_model)
    h = wc_lang.SpeciesType(id='h', name='H+', model=prog_model)

    # create an 'ATP hydrolysis' reaction that uses these species types
    atp_hydrolysis = wc_lang.Reaction(id='atp_hydrolysis', name='ATP hydrolysis')

    # add two reactants, which have negative stoichiometric coefficients
    atp_hydrolysis.participants.create(
        species=wc_lang.Species(id='atp[c]', species_type=atp, compartment=cytosol), coefficient=-1)
    atp_hydrolysis.participants.create(
        species=wc_lang.Species(id='h2o[c]', species_type=h2o, compartment=cytosol), coefficient=-1)

    # add three products, with positive stoichiometric coefficients
    atp_hydrolysis.participants.create(
        species=wc_lang.Species(id='adp[c]', species_type=adp, compartment=cytosol), coefficient=1)
    atp_hydrolysis.participants.create(
        species=wc_lang.Species(id='pi[c]', species_type=pi, compartment=cytosol), coefficient=1)
    atp_hydrolysis.participants.create(
        species=wc_lang.Species(id='h[c]', species_type=h, compartment=cytosol), coefficient=1)
    # The previous illustrates how to program a trivial model
    # Don't change the previous comment - it's used by a literalinclude

    results.append("created model: '{}'".format(prog_model.name))

    # Don't change the next comment - it's used by a literalinclude
    # so that this assertion holds
    assert(atp in prog_model.get_species_types())

    # Don't change the next comment - it's used by a literalinclude
    # these assertions hold
    # 5 participants were added to the reaction
    assert(len(atp_hydrolysis.participants) == 5)
    first_reaction_participant = atp_hydrolysis.participants[0]
    assert(first_reaction_participant.reactions[0] is atp_hydrolysis)

    # Don't change the next comment - it's used by a literalinclude
    # The attribues that can be initialized when a ``wc_lang.BaseModel`` class is instantiated
    wc_lang.Model.Meta.attributes.keys()
    wc_lang.Submodel.Meta.attributes.keys()
    wc_lang.SpeciesType.Meta.attributes.keys()
    wc_lang.Compartment.Meta.attributes.keys()

    # Don't change the next comment - it's used by a literalinclude
    # The following illustrates how to edit a model programmatically
    atp_hydrolysis.comments = 'example comments'
    atp_hydrolysis.reversible = False

    #################################################
    # Viewing Models and their attributes
    #################################################

    # pprint example
    atp_hydrolysis.participants[0].pprint(max_depth=1)

    #################################################
    # Finding model components
    #################################################

    #################################################
    # Completing and validating models
    #################################################

    # Don't change the next comment - it's used by a literalinclude
    # This example illustrates how to validate ``prog_model``
    prog_model.validate()

    rv = prog_model.validate()
    results.append("validate model: '{}'".format(rv))

    # TODO: make this work: print(atp_hydrolysis.participants[0].reaction)
    # TODO: make this work: print('len(atp_hydrolysis.participants)', len(atp_hydrolysis.participants))

    #################################################
    # Comparing and differencing models
    #################################################

    # Don't change the next comment - it's used by a literalinclude
    # compare the semantic equality of ``model`` and ``model_from_tsv``
    assert(model.is_equal(model_from_tsv) == True)

    # Don't change the next comment - it's used by a literalinclude
    # produces a textual description of the differences between two models
    assert(model.difference(model_from_tsv) == '')

    #################################################
    # Normalizing models into a reproducible order
    #################################################

    # Don't change the next comment - it's used by a literalinclude
    # The following code excerpt will normalize ``model`` into a reproducible order
    model.normalize()

    rv = model.normalize()
    results.append("normalize model: '{}'".format(rv))

    return results
Exemple #3
0
    def test_gen_mass_action_rate_law(self):
        model = wc_lang.Model()
        c = wc_lang.Compartment(id='c',
                                init_volume=wc_lang.InitVolume(mean=0.5))
        c.init_density = wc_lang.Parameter(id='density_' + c.id, value=1.)
        kinetic_parameter = wc_lang.Parameter(id='this_parameter', 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)

        species_types = {}
        species = {}
        for i in range(1, 7):
            Id = 's' + str(i)
            species_types[Id] = wc_lang.SpeciesType(id=Id)
            species[Id + '_c'] = wc_lang.Species(
                species_type=species_types[Id], compartment=c)
            wc_lang.DistributionInitConcentration(species=species[Id + '_c'],
                                                  mean=0.5)
        Id = 'e'
        species_types[Id] = wc_lang.SpeciesType(id=Id)
        species[Id + '_c'] = wc_lang.Species(species_type=species_types[Id],
                                             compartment=c)
        wc_lang.DistributionInitConcentration(species=species[Id + '_c'],
                                              mean=0.5)

        # ob_exp1, error = wc_lang.ObservableExpression.deserialize('s4[c] + s5[c]', {
        #     wc_lang.Species:{species['s4_c'].gen_id(): species['s4_c'],
        #                     species['s5_c'].gen_id(): species['s5_c']}})
        # assert error is None, str(error)
        # modifier1 = wc_lang.Observable(id='e1', expression=ob_exp1)

        # ob_exp2, error = wc_lang.ObservableExpression.deserialize('2 * s6[c]', {
        #     wc_lang.Species:{species['s6_c'].gen_id(): species['s6_c']}})
        # assert error is None, str(error)
        # modifier2 = wc_lang.Observable(id='e2', expression=ob_exp2)

        participant1 = wc_lang.SpeciesCoefficient(species=species['s1_c'],
                                                  coefficient=-1)
        participant2 = wc_lang.SpeciesCoefficient(species=species['s2_c'],
                                                  coefficient=-1)
        participant3 = wc_lang.SpeciesCoefficient(species=species['s3_c'],
                                                  coefficient=1)
        participant4 = wc_lang.SpeciesCoefficient(species=species['s4_c'],
                                                  coefficient=1)
        enzyme_lhs = wc_lang.SpeciesCoefficient(species=species['e_c'],
                                                coefficient=-1)
        enzyme_rhs = wc_lang.SpeciesCoefficient(species=species['e_c'],
                                                coefficient=1)

        reaction = wc_lang.Reaction(
            id='Assosication',
            participants=[participant1, participant2, participant3])
        rate_law, parameters = utils.gen_mass_action_rate_law(
            model, reaction, kinetic_parameter)
        self.assertTrue(
            rate_law.expression == 'this_parameter * s1[c] * s2[c]'
            or rate_law.expression == 'this_parameter * s2[c] * s1[c]')
        self.assertEqual(set([i.gen_id() for i in rate_law.species]),
                         set(['s1[c]', 's2[c]']))
        # self.assertEqual(set(rate_law.observables), set([modifier1, modifier2]))
        self.assertEqual(set(rate_law.parameters), set(parameters))
        # self.assertEqual(rate_law.parameters.get_one(id='k_r1').type, wc_ontology['WC:k_cat'])
        self.assertEqual(
            rate_law.parameters.get_one(id='this_parameter').units,
            unit_registry.parse_units('s^-1 * molecule^-1'))
        # self.assertEqual(rate_law.parameters.get_one(id='K_m_r1_s2').type, wc_ontology['WC:K_m'])
        # self.assertEqual(rate_law.parameters.get_one(id='K_m_r1_s2').units, unit_registry.parse_units('M'))

        reaction = wc_lang.Reaction(
            id='Dissociation',
            participants=[participant1, participant3, participant4])
        rate_law, parameters = utils.gen_mass_action_rate_law(
            model, reaction, kinetic_parameter)
        self.assertEqual(rate_law.expression, 'this_parameter * s1[c]')
        self.assertEqual(set([i.gen_id() for i in rate_law.species]),
                         set(['s1[c]']))
        self.assertEqual(
            rate_law.parameters.get_one(id='this_parameter').units,
            unit_registry.parse_units('s^-1'))

        reaction = wc_lang.Reaction(id='Degradation1',
                                    participants=[participant1])
        rate_law, parameters = utils.gen_mass_action_rate_law(
            model, reaction, kinetic_parameter)
        self.assertEqual(rate_law.expression, 'this_parameter * s1[c]')
        self.assertEqual(set([i.gen_id() for i in rate_law.species]),
                         set(['s1[c]']))
        self.assertEqual(
            rate_law.parameters.get_one(id='this_parameter').units,
            unit_registry.parse_units('s^-1'))

        reaction = wc_lang.Reaction(
            id='Degradation2',
            participants=[participant1, enzyme_lhs, enzyme_rhs])
        rate_law, parameters = utils.gen_mass_action_rate_law(
            model, reaction, kinetic_parameter)
        self.assertTrue(
            rate_law.expression, 'this_parameter * s1[c] * e[c]'
            or 'this_parameter * e[c] * s1[c]')
        self.assertEqual(set([i.gen_id() for i in rate_law.species]),
                         set(['s1[c]', 'e[c]']))
        self.assertEqual(
            rate_law.parameters.get_one(id='this_parameter').units,
            unit_registry.parse_units('s^-1 * molecule^-1'))

        reaction = wc_lang.Reaction(id='Synthesis1',
                                    participants=[participant3])
        rate_law, parameters = utils.gen_mass_action_rate_law(
            model, reaction, kinetic_parameter)
        self.assertEqual(rate_law.expression, 'this_parameter')
        self.assertEqual(set([i.gen_id() for i in rate_law.species]), set([]))
        self.assertEqual(
            rate_law.parameters.get_one(id='this_parameter').units,
            unit_registry.parse_units('s^-1 * molecule'))

        reaction = wc_lang.Reaction(
            id='Synthesis2',
            participants=[enzyme_lhs, enzyme_rhs, participant3])
        rate_law, parameters = utils.gen_mass_action_rate_law(
            model, reaction, kinetic_parameter)
        self.assertEqual(rate_law.expression, 'this_parameter * e[c]')
        self.assertEqual(set([i.gen_id() for i in rate_law.species]),
                         set(['e[c]']))
        self.assertEqual(
            rate_law.parameters.get_one(id='this_parameter').units,
            unit_registry.parse_units('s^-1'))

        reaction = wc_lang.Reaction(
            id='Conversion',
            participants=[participant1, enzyme_lhs, enzyme_rhs, participant3]
        )  # Ask Yin Hoon why I can add as many copies of participant2 as I want.
        rate_law, parameters = utils.gen_mass_action_rate_law(
            model, reaction, kinetic_parameter)
        self.assertTrue(
            rate_law.expression == 'this_parameter * s1[c] * e[c]'
            or rate_law.expression == 'this_parameter * e[c] * s1[c]')
        self.assertEqual(set([i.gen_id() for i in rate_law.species]),
                         set(['s1[c]', 'e[c]']))
        self.assertEqual(
            rate_law.parameters.get_one(id='this_parameter').units,
            unit_registry.parse_units('s^-1 * molecule^-1'))
Exemple #4
0
    def test_gen_response_functions(self):
        model = wc_lang.Model()
        beta = 2

        init_volume = wc_lang.core.InitVolume(
            distribution=wc_ontology['WC:normal_distribution'],
            mean=0.5,
            std=0)
        c = wc_lang.Compartment(id='c',
                                name='cytosol',
                                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)

        reaction = wc_lang.Reaction()

        species_types = {}
        species = {}
        for i in range(1, 5):
            Id = 's' + str(i)
            species_types[Id] = wc_lang.SpeciesType(
                model=model, id=Id, name='species_type_{}'.format(i))
            model_species = wc_lang.Species(model=model,
                                            species_type=species_types[Id],
                                            compartment=c)
            model_species.id = model_species.gen_id()
            species[Id + '_c'] = model_species
            wc_lang.DistributionInitConcentration(species=species[Id + '_c'],
                                                  mean=0.5)

        factors = [['s1', 'species_type_2'], ['s3'], ['species_type_4']]
        factor_exp, all_species, all_parameters, all_volumes, all_observables = utils.gen_response_functions(
            model, beta, 'reaction_id', 'reaction_class', c, factors)

        self.assertEqual(factor_exp, [
            '(reaction_class_factors_c_1 / (reaction_class_factors_c_1 + K_m_reaction_class_reaction_class_factors_c_1 * Avogadro * volume_c))',
            '(s3[c] / (s3[c] + K_m_reaction_id_s3 * Avogadro * volume_c))',
            '(s4[c] / (s4[c] + K_m_reaction_id_s4 * Avogadro * volume_c))'
        ])
        self.assertEqual(
            all_species, {
                's1[c]': species['s1_c'],
                's2[c]': species['s2_c'],
                's3[c]': species['s3_c'],
                's4[c]': species['s4_c']
            })
        self.assertEqual(len(all_parameters), 4)
        self.assertEqual(all_parameters['Avogadro'].value,
                         scipy.constants.Avogadro)
        self.assertEqual(all_parameters['Avogadro'].units,
                         unit_registry.parse_units('molecule mol^-1'))
        self.assertEqual(
            all_parameters['K_m_reaction_class_reaction_class_factors_c_1'].
            value, beta * 1. / scipy.constants.Avogadro / c.init_volume.mean)
        self.assertEqual(
            all_parameters['K_m_reaction_class_reaction_class_factors_c_1'].
            comments,
            'The value was assumed to be 2 times the value of reaction_class_factors_c_1'
        )
        self.assertEqual(
            all_parameters['K_m_reaction_id_s3'].value,
            beta * 0.5 / scipy.constants.Avogadro / c.init_volume.mean)
        self.assertEqual(all_parameters['K_m_reaction_id_s4'].type,
                         wc_ontology['WC:K_m'])
        self.assertEqual(all_parameters['K_m_reaction_id_s4'].units,
                         unit_registry.parse_units('M'))
        self.assertEqual(
            all_parameters['K_m_reaction_id_s4'].comments,
            'The value was assumed to be 2 times the concentration of s4 in cytosol'
        )
        self.assertEqual(all_volumes, {'volume_c': volume})
        self.assertEqual(len(all_observables), 1)
        self.assertEqual(len(model.observables), 1)
        self.assertEqual(all_observables['reaction_class_factors_c_1'].name,
                         'factor for reaction_class in cytosol')
        self.assertEqual(all_observables['reaction_class_factors_c_1'].units,
                         unit_registry.parse_units('molecule'))
        self.assertEqual(
            all_observables['reaction_class_factors_c_1'].expression.
            expression, 's1[c] + s2[c]')

        for i in range(5, 9):
            Id = 's' + str(i)
            species_types[Id] = wc_lang.SpeciesType(
                model=model, id=Id, name='species_type_{}'.format(i))
            model_species = wc_lang.Species(model=model,
                                            species_type=species_types[Id],
                                            compartment=c)
            model_species.id = model_species.gen_id()
            species[Id + '_c'] = model_species
            wc_lang.DistributionInitConcentration(species=species[Id + '_c'],
                                                  mean=0.)

        factors = [['s5', 'species_type_6'], ['s7'], ['species_type_8']]
        factor_exp, all_species, all_parameters, all_volumes, all_observables = utils.gen_response_functions(
            model, beta, 'reaction_id', 'reaction_class', c, factors)

        self.assertEqual(len(model.observables), 2)
        self.assertEqual(
            all_parameters['K_m_reaction_class_reaction_class_factors_c_2'].
            value, 1e-05)
        self.assertEqual(
            all_parameters['K_m_reaction_class_reaction_class_factors_c_2'].
            comments,
            'The value was assigned to 1e-05 because the value of reaction_class_factors_c_2 was zero'
        )
        self.assertEqual(all_parameters['K_m_reaction_id_s7'].value, 1e-05)
        self.assertEqual(
            all_parameters['K_m_reaction_id_s8'].comments,
            'The value was assigned to 1e-05 because the concentration of s8 in cytosol was zero'
        )

        factors = [['s5', 'species_type_6']]
        factor_exp, all_species, all_parameters, all_volumes, all_observables = utils.gen_response_functions(
            model, beta, 'reaction_id2', 'reaction_class2', c, factors)

        self.assertEqual(len(model.observables), 2)
        self.assertEqual(
            all_parameters['K_m_reaction_class2_reaction_class_factors_c_2'].
            value, 1e-05)
Exemple #5
0
    def test_gen_michaelis_menten_like_propensity_function(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)

        species_types = {}
        species = {}
        for i in range(1, 7):
            Id = 's' + str(i)
            species_types[Id] = wc_lang.SpeciesType(id=Id)
            model_species = wc_lang.Species(species_type=species_types[Id],
                                            compartment=c)
            model_species.id = model_species.gen_id()
            species[Id + '_c'] = model_species
            wc_lang.DistributionInitConcentration(species=species[Id + '_c'],
                                                  mean=0.5)

        participant1 = wc_lang.SpeciesCoefficient(species=species['s1_c'],
                                                  coefficient=-1)
        participant2 = wc_lang.SpeciesCoefficient(species=species['s2_c'],
                                                  coefficient=-1)
        participant3 = wc_lang.SpeciesCoefficient(species=species['s3_c'],
                                                  coefficient=-1)
        participant4 = wc_lang.SpeciesCoefficient(species=species['s4_c'],
                                                  coefficient=-1)
        participant5 = wc_lang.SpeciesCoefficient(species=species['s5_c'],
                                                  coefficient=1)
        participant6 = wc_lang.SpeciesCoefficient(species=species['s6_c'],
                                                  coefficient=1)

        reaction = wc_lang.Reaction(id='r1',
                                    participants=[
                                        participant1, participant2,
                                        participant3, participant4,
                                        participant5, participant6
                                    ])

        with self.assertRaises(ValueError):
            rate_law1, parameters = utils.gen_michaelis_menten_like_propensity_function(
                model, reaction)

        rate_law2, parameters = utils.gen_michaelis_menten_like_propensity_function(
            model, reaction, substrates_as_modifiers=[species['s3_c']])
        self.assertEqual(
            rate_law2.expression, 'k_cat_r1 * s3[c] * '
            '(s1[c] / (s1[c] + K_m_r1_s1 * Avogadro * volume_c)) * '
            '(s2[c] / (s2[c] + K_m_r1_s2 * Avogadro * volume_c)) * '
            '(s4[c] / (s4[c] + K_m_r1_s4 * Avogadro * volume_c))')
        self.assertEqual(set([i.gen_id() for i in rate_law2.species]),
                         set(['s1[c]', 's2[c]', 's3[c]', 's4[c]']))
        self.assertEqual(set(rate_law2.parameters), set(parameters))
        self.assertEqual(
            rate_law2.parameters.get_one(id='k_cat_r1').type,
            wc_ontology['WC:k_cat'])
        self.assertEqual(
            rate_law2.parameters.get_one(id='k_cat_r1').units,
            unit_registry.parse_units('s^-1 molecule^-1'))
        self.assertEqual(
            rate_law2.parameters.get_one(id='K_m_r1_s2').type,
            wc_ontology['WC:K_m'])
        self.assertEqual(
            rate_law2.parameters.get_one(id='K_m_r1_s2').units,
            unit_registry.parse_units('M'))

        rate_law3, parameters = utils.gen_michaelis_menten_like_propensity_function(
            model,
            reaction,
            substrates_as_modifiers=[species['s3_c']],
            exclude_substrates=[species['s1_c']])
        self.assertEqual(
            rate_law3.expression, 'k_cat_r1 * s3[c] * '
            '(s2[c] / (s2[c] + K_m_r1_s2 * Avogadro * volume_c)) * '
            '(s4[c] / (s4[c] + K_m_r1_s4 * Avogadro * volume_c))')
        self.assertEqual(set([i.gen_id() for i in rate_law3.species]),
                         set(['s2[c]', 's3[c]', 's4[c]']))
        self.assertEqual(set(rate_law3.parameters), set(parameters))
Exemple #6
0
    def test_gen_michaelis_menten_like_rate_law(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)

        species_types = {}
        species = {}
        for i in range(1, 7):
            Id = 's' + str(i)
            species_types[Id] = wc_lang.SpeciesType(id=Id)
            species[Id + '_c'] = wc_lang.Species(
                species_type=species_types[Id], compartment=c)
            wc_lang.DistributionInitConcentration(species=species[Id + '_c'],
                                                  mean=0.5)

        ob_exp1, error = wc_lang.ObservableExpression.deserialize(
            's4[c] + s5[c]', {
                wc_lang.Species: {
                    species['s4_c'].gen_id(): species['s4_c'],
                    species['s5_c'].gen_id(): species['s5_c']
                }
            })
        assert error is None, str(error)
        modifier1 = wc_lang.Observable(id='e1', expression=ob_exp1)

        ob_exp2, error = wc_lang.ObservableExpression.deserialize(
            '2 * s6[c]',
            {wc_lang.Species: {
                species['s6_c'].gen_id(): species['s6_c']
            }})
        assert error is None, str(error)
        modifier2 = wc_lang.Observable(id='e2', expression=ob_exp2)

        participant1 = wc_lang.SpeciesCoefficient(species=species['s1_c'],
                                                  coefficient=-1)
        participant2 = wc_lang.SpeciesCoefficient(species=species['s2_c'],
                                                  coefficient=-1)
        participant3 = wc_lang.SpeciesCoefficient(species=species['s3_c'],
                                                  coefficient=1)
        participant4 = wc_lang.SpeciesCoefficient(species=species['s4_c'],
                                                  coefficient=-1)
        participant5 = wc_lang.SpeciesCoefficient(species=species['s4_c'],
                                                  coefficient=1)
        participant6 = wc_lang.SpeciesCoefficient(species=species['s6_c'],
                                                  coefficient=-1)
        participant7 = wc_lang.SpeciesCoefficient(species=species['s6_c'],
                                                  coefficient=-1)
        participant8 = wc_lang.SpeciesCoefficient(species=species['s6_c'],
                                                  coefficient=1)
        reaction = wc_lang.Reaction(id='r1',
                                    participants=[
                                        participant1, participant2,
                                        participant3, participant4,
                                        participant5, participant6,
                                        participant7, participant8
                                    ])

        rate_law, parameters = utils.gen_michaelis_menten_like_rate_law(
            model,
            reaction,
            modifiers=[modifier1, modifier2],
            modifier_reactants=[species['s6_c']])

        self.assertEqual(
            rate_law.expression, 'k_cat_r1 * e1 * e2 * '
            '(s1[c] / (s1[c] + K_m_r1_s1 * Avogadro * volume_c)) * '
            '(s2[c] / (s2[c] + K_m_r1_s2 * Avogadro * volume_c)) * '
            '(s6[c] / (s6[c] + K_m_r1_s6 * Avogadro * volume_c))')
        self.assertEqual(set([i.gen_id() for i in rate_law.species]),
                         set(['s1[c]', 's2[c]', 's6[c]']))
        self.assertEqual(set(rate_law.observables), set([modifier1,
                                                         modifier2]))
        self.assertEqual(set(rate_law.parameters), set(parameters))
        self.assertEqual(
            rate_law.parameters.get_one(id='k_cat_r1').type,
            wc_ontology['WC:k_cat'])
        self.assertEqual(
            rate_law.parameters.get_one(id='k_cat_r1').units,
            unit_registry.parse_units('s^-1 molecule^-2'))
        self.assertEqual(
            rate_law.parameters.get_one(id='K_m_r1_s2').type,
            wc_ontology['WC:K_m'])
        self.assertEqual(
            rate_law.parameters.get_one(id='K_m_r1_s2').units,
            unit_registry.parse_units('M'))

        reaction = wc_lang.Reaction(id='r1',
                                    participants=[
                                        participant1, participant2,
                                        participant4, participant8
                                    ])
        rate_law, parameters = utils.gen_michaelis_menten_like_rate_law(
            model, reaction)
        self.assertEqual(
            rate_law.expression, 'k_cat_r1 * '
            '(s1[c] / (s1[c] + K_m_r1_s1 * Avogadro * volume_c)) * '
            '(s2[c] / (s2[c] + K_m_r1_s2 * Avogadro * volume_c)) * '
            '(s4[c] / (s4[c] + K_m_r1_s4 * Avogadro * volume_c))')

        reaction = wc_lang.Reaction(id='r1', participants=[participant3])
        rate_law, parameters = utils.gen_michaelis_menten_like_rate_law(
            model, reaction)
        self.assertEqual(rate_law.expression, 'k_cat_r1')

        reaction = wc_lang.Reaction(id='r1',
                                    participants=[participant3, participant6])
        rate_law, parameters = utils.gen_michaelis_menten_like_rate_law(
            model, reaction, modifiers=[modifier1, species['s6_c']])
        self.assertEqual(rate_law.expression, 'k_cat_r1 * e1 * s6[c]')

        reaction = wc_lang.Reaction(id='r1',
                                    participants=[
                                        participant1, participant2,
                                        participant4, participant8
                                    ])
        rate_law, parameters = utils.gen_michaelis_menten_like_rate_law(
            model, reaction, exclude_substrates=[species['s1_c']])
        self.assertEqual(
            rate_law.expression, 'k_cat_r1 * '
            '(s2[c] / (s2[c] + K_m_r1_s2 * Avogadro * volume_c)) * '
            '(s4[c] / (s4[c] + K_m_r1_s4 * Avogadro * volume_c))')

        with self.assertRaises(TypeError) as ctx:
            rate_law, parameters = utils.gen_michaelis_menten_like_rate_law(
                model, reaction, modifiers=['s6_c'])
        self.assertEqual(
            'The modifiers contain element(s) that is not an observable or a species',
            str(ctx.exception))