Ejemplo n.º 1
0
    def test_find_sparse_mode_singleton(self):
        p = fastcore.FastcoreProblem(self.model, self.solver, epsilon=0.001)
        core = {'rxn_1'}
        mode = set(p.find_sparse_mode(
            core, set(self.model.reactions) - core, scaling=1e3))
        self.assertEqual(mode, {'rxn_1', 'rxn_3', 'rxn_6'})

        core = {'rxn_2'}
        mode = set(p.find_sparse_mode(
            core, set(self.model.reactions) - core, scaling=1e3))
        self.assertEqual(mode, set())

        core = {'rxn_3'}
        mode = set(p.find_sparse_mode(
            core, set(self.model.reactions) - core, scaling=1e3))
        self.assertEqual(mode, {'rxn_1', 'rxn_3', 'rxn_6'})

        core = {'rxn_4'}
        mode = set(p.find_sparse_mode(
            core, set(self.model.reactions) - core, scaling=1e3))
        self.assertEqual(mode, {'rxn_1', 'rxn_4', 'rxn_5', 'rxn_6'})

        core = {'rxn_5'}
        mode = set(p.find_sparse_mode(
            core, set(self.model.reactions) - core, scaling=1e3))
        self.assertEqual(mode, {'rxn_1', 'rxn_4', 'rxn_5', 'rxn_6'})

        core = {'rxn_6'}
        mode = set(p.find_sparse_mode(
            core, set(self.model.reactions) - core, scaling=1e3))
        self.assertEqual(mode, {'rxn_1', 'rxn_3', 'rxn_6'})
Ejemplo n.º 2
0
 def test_lp10(self):
     p = fastcore.FastcoreProblem(self.model, self.solver, epsilon=0.001)
     scaling = 1000
     p.lp10({'rxn_6'}, {'rxn_1', 'rxn_3', 'rxn_4', 'rxn_5'})
     supp = set(reaction_id for reaction_id in self.model.reactions
                if abs(p.get_flux(reaction_id)) >= 0.999 * 0.001 / scaling)
     self.assertEqual(supp, { 'rxn_1', 'rxn_3', 'rxn_6' })
Ejemplo n.º 3
0
    def test_lp7(self):
        p = fastcore.FastcoreProblem(self.model, self.solver, epsilon=0.001)
        p.lp7(set(self.model.reactions))
        supp = set(reaction_id for reaction_id in self.model.reactions
                   if p.get_flux(reaction_id) >= 0.001*0.999)
        self.assertEqual(supp, {'rxn_1', 'rxn_3', 'rxn_4', 'rxn_5', 'rxn_6'})

        p.lp7({'rxn_5'})
        supp = set(reaction_id for reaction_id in self.model.reactions
                   if p.get_flux(reaction_id) >= 0.001*0.999)
        # Test that the support contains at least the given reactions
        self.assertLessEqual({'rxn_4', 'rxn_5', 'rxn_6'}, supp)
Ejemplo n.º 4
0
    def test_find_sparse_mode_weighted(self):
        p = fastcore.FastcoreProblem(self.model, self.solver, epsilon=0.001)
        core = {'rxn_1'}
        weights = {'rxn_3': 1}
        mode = set(p.find_sparse_mode(
            core, set(self.model.reactions) - core,
            scaling=1e3, weights=weights))
        self.assertEqual(mode, {'rxn_1', 'rxn_3', 'rxn_6'})

        weights = {'rxn_3': 3}
        mode = set(p.find_sparse_mode(
            core, set(self.model.reactions) - core,
            scaling=1e3, weights=weights))
        self.assertEqual(mode, {'rxn_1', 'rxn_4', 'rxn_5', 'rxn_6'})