def test_exception(self):
        """
        Forget the trailing 'end' and ensure it produces an error
        :return:
        """
        exception_message = "Antimony: Error in model string, line 19:  syntax error, unexpected end of file, expecting '-' or '+' or => or '<'"
        try:
            with model.BuildAntimony(self.copasi_file2) as loader:
                self.mod2 = loader.load("""
                    model model2
                        compartment cell = 1.0
                        var A in cell
                        var B in cell
    
                        vAProd = 0.1
                        kADeg = 0.2
                        kBProd = 0.3
                        kBDeg = 0.4
                        vBasalAProd = 0.001
                        A = 0
                        B = 0
    
                        AProd: => A; cell*vAProd*B+vBasalAProd
                        ADeg: A =>; cell*kADeg*A
                        BProd: => B; cell*kBProd*A
                        BDeg: B => ; cell*kBDeg*B
                    """)

        except Exception as E:
            self.assertEqual(str(E.message), str(exception_message))
    def setUp(self):
        ## create model selection directory

        self.dire = os.path.join(os.path.dirname(__file__), 'AntimonyModels')
        if not os.path.isdir(self.dire):
            os.makedirs(self.dire)

        self.copasi_file1 = os.path.join(self.dire, 'negative_feedback.cps')

        with model.BuildAntimony(self.copasi_file1) as loader:
            self.mod = loader.load("""
                model model1
                    compartment cell = 1.0
                    var A in cell
                    var B in cell

                    vAProd = 0.1
                    kADeg = 0.2
                    kBProd = 0.3
                    kBDeg = 0.4
                    vBasalAProd = 0.001
                    A = 0
                    B = 0

                    AProd: => A; cell*vAProd*B+vBasalAProd
                    ADeg: A =>; cell*kADeg*A
                    BProd: => B; cell*kBProd*A
                    BDeg: B => ; cell*kBDeg*B
                end
                """)

        assert os.path.isfile(self.copasi_file1)
    def test_build(self):
        """
        Make copasi file from antimony
        :return:
        """
        with model.BuildAntimony(self.copasi_file1) as loader:
            self.mod1 = loader.load("""
                model model1
                    compartment cell = 1.0
                    var A in cell
                    var B in cell

                    vAProd = 0.1
                    kADeg = 0.2
                    kBProd = 0.3
                    kBDeg = 0.4
                    A = 0
                    B = 0

                    AProd: => A; cell*vAProd
                    ADeg: A =>; cell*kADeg*A*B
                    BProd: => B; cell*kBProd*A
                    BDeg: B => ; cell*kBDeg*B
                end
                """)
        self.assertTrue(os.path.isfile(self.copasi_file1))
Exemple #4
0
    def setUp(self):
        ## create model selection directory

        self.dire = os.path.join(os.path.dirname(__file__), 'AntimonyModels')
        if not os.path.isdir(self.dire):
            os.makedirs(self.dire)

        self.copasi_file1 = os.path.join(self.dire, 'negative_feedback.cps')

        with model.BuildAntimony(self.copasi_file1) as loader:
            self.mod = loader.load("""
                model model1
                    compartment cell = 1.0
                    var A in cell
                    var B in cell

                    vAProd = 0.1
                    kADeg = 0.2
                    kBProd = 0.3
                    kBDeg = 0.4
                    vBasalAProd = 0.001
                    A = 0
                    B = 0

                    AProd: => A; cell*vAProd*B+vBasalAProd
                    ADeg: A =>; cell*kADeg*A
                    BProd: => B; cell*kBProd*A
                    BDeg: B => ; cell*kBDeg*B
                end
                """)
        if not os.path.isfile(self.copasi_file1):
            raise errors.FileDoesNotExistError(
                'Copasi File "{}" was not created in '
                'setting up the test case'.format(self.copasi_file1))
    def setUp(self):
        self.working_directory = os.path.join(os.path.dirname(__file__),
                                              'viz_tests')
        if not os.path.isdir(self.working_directory):
            os.makedirs(self.working_directory)

        copasi_file = os.path.join(self.working_directory, 'test_model.cps')
        with model.BuildAntimony(copasi_file) as loader:
            self.mod = loader.load("""
                model negative_feedback
                    compartment cell = 1.0
                    var A in cell
                    var B in cell
                    var Signal in cell
                    var C in cell

                    vAProd = 0.1
                    kADeg = 0.2
                    kBProd = 0.3
                    kBDeg = 0.4
                    kCProd = 0.5
                    kCDeg = 0.6
                    A = 0
                    B = 0
                    C = 0
                    Signal = 10

                    AProd: $Signal => A; cell*vAProd*Signal
                    ADeg: A =>; cell*kADeg*A*B;
                    BProd: => B; cell*kBProd*A;
                    BDeg: B => ; cell*kBDeg*B;
                    CProd: => C ; cell*kCProd*B;
                    CDeg: C => ; cell*kCDeg*C
                end
                """)

        ## initialize empty dict to store TimeCourse objects
        self.TC = tasks.TimeCourse(self.mod,
                                   end=10,
                                   intervals=10,
                                   step_size=1,
                                   global_quantities=[],
                                   y=['A', 'B', 'C'])
        tasks

        ## format the time course data
        df = utils.format_timecourse_data(self.TC.report_name)

        ## write data to file
        df.to_csv(self.TC.report_name, sep='\t', index=False)

        self.MPE = tasks.MultiParameterEstimation(self.mod,
                                                  self.TC.report_name,
                                                  method='genetic_algorithm',
                                                  population_size=25,
                                                  number_of_generations=50,
                                                  run_mode=True)
        self.MPE.write_config_file()
        self.MPE.setup()
        self.MPE.run()
    def setUp(self):
        ## create model selection directory

        self.dire = os.path.join(os.path.dirname(__file__),
                                 'profile_likelihood_latex_tests')
        if not os.path.isdir(self.dire):
            os.makedirs(self.dire)

        self.copasi_file = os.path.join(self.dire, 'negative_feedback.cps')

        with model.BuildAntimony(self.copasi_file) as loader:
            self.mod = loader.load("""
                model model1
                    compartment cell = 1.0
                    var A in cell
                    var B in cell

                    vAProd = 0.1
                    kADeg = 0.2
                    kBProd = 0.3
                    kBDeg = 0.4
                    A = 0
                    B = 0

                    AProd: => A; cell*vAProd
                    ADeg: A =>; cell*kADeg*A*B
                    BProd: => B; cell*kBProd*A
                    BDeg: B => ; cell*kBDeg*B
                end
                """)

        self.TC = self.simulate_data()

        self.MPE = self.do_parameter_estimation()

        self.pl = self.do_profile_likelihood()

        self.filename = os.path.join(self.dire, 'latex_test.pdf')
    def test_build_model_to_file_path_which_already_exists(self):
        with model.BuildAntimony(self.copasi_file1) as loader:
            mod = loader.load("""
                model model1
                    compartment cell = 1.0
                    var A in cell
                    var C in cell

                    vAProd = 0.1
                    kADeg = 0.2
                    kCProd = 0.3
                    kCDeg = 0.4
                    vBasalAProd = 0.001
                    A = 0
                    C = 0

                    AProd: => A; cell*vAProd*B+vBasalAProd
                    ADeg: A =>; cell*kADeg*A
                    CProd: => C; cell*kCProd*A
                    CDeg: C => ; cell*kCDeg*C
                end
                """)

        self.assertNotIn('B', [i.name for i in mod.metabolites])
Exemple #8
0
    def setUp(self):
        ## create model selection directory

        self.dire = os.path.join(os.path.dirname(__file__),
                                 'ChaserEstimationTests')
        if not os.path.isdir(self.dire):
            os.makedirs(self.dire)

        self.copasi_file = os.path.join(self.dire, 'negative_feedback.cps')

        with model.BuildAntimony(self.copasi_file) as loader:
            self.mod = loader.load("""
                model model1
                    compartment cell = 1.0
                    var A in cell
                    var B in cell

                    vAProd = 0.1
                    kADeg = 0.2
                    kBProd = 0.3
                    kBDeg = 0.4
                    vBasalAProd = 0.001
                    A = 0
                    B = 0

                    AProd: => A; cell*vAProd*B+vBasalAProd
                    ADeg: A =>; cell*kADeg*A
                    BProd: => B; cell*kBProd*A
                    BDeg: B => ; cell*kBDeg*B
                end
                """)

        self.TC1 = tasks.TimeCourse(self.mod,
                                    end=1000,
                                    step_size=100,
                                    intervals=10,
                                    report_name='report1.txt')

        utils.format_timecourse_data(self.TC1.report_name)
        ## add some noise
        data1 = misc.add_noise(self.TC1.report_name)

        ## remove the data
        os.remove(self.TC1.report_name)

        ## rewrite the data with noise
        data1.to_csv(self.TC1.report_name, sep='\t')

        self.copy_number = 2
        self.pe_number = 3

        self.MPE = tasks.MultiParameterEstimation(self.mod,
                                                  self.TC1.report_name,
                                                  copy_number=self.copy_number,
                                                  pe_number=self.pe_number,
                                                  method='genetic_algorithm',
                                                  population_size=10,
                                                  number_of_generations=10,
                                                  overwrite_config_file=True,
                                                  results_directory='test_mpe',
                                                  run_mode=True)

        self.list_of_tasks = '{http://www.copasi.org/static/schema}ListOfTasks'

        self.MPE.write_config_file()
        self.MPE.setup()
        self.MPE.run()
    def setUp(self):
        ## create model selection directory

        self.dire = os.path.join(os.path.dirname(__file__), 'model_selection')
        if not os.path.isdir(self.dire):
            os.makedirs(self.dire)

        self.copasi_file1 = os.path.join(self.dire, 'negative_feedback.cps')
        self.copasi_file2 = os.path.join(self.dire, 'positive_feedback.cps')
        self.copasi_file3 = os.path.join(self.dire, 'feedforward.cps')

        with model.BuildAntimony(self.copasi_file1) as loader:
            self.mod1 = loader.load(
                """
                model model1
                    compartment cell = 1.0
                    var A in cell
                    var B in cell
                    
                    vAProd = 0.1
                    kADeg = 0.2
                    kBProd = 0.3
                    kBDeg = 0.4
                    A = 0
                    B = 0

                    AProd: => A; cell*vAProd
                    ADeg: A =>; cell*kADeg*A*B
                    BProd: => B; cell*kBProd*A
                    BDeg: B => ; cell*kBDeg*B
                end
                """
            )

        with model.BuildAntimony(self.copasi_file2) as loader:
            self.mod2 = loader.load(
                """
                model model2
                    compartment cell = 1.0
                    var A in cell
                    var B in cell

                    vAProd = 0.1
                    kADeg = 0.2
                    kBProd = 0.3
                    kBDeg = 0.4
                    vBasalAProd = 0.001
                    A = 0
                    B = 0

                    AProd: => A; cell*vAProd*B+vBasalAProd
                    ADeg: A =>; cell*kADeg*A
                    BProd: => B; cell*kBProd*A
                    BDeg: B => ; cell*kBDeg*B
                end
                """
            )

        with model.BuildAntimony(self.copasi_file3) as loader:
            self.mod3 = loader.load(
                """
                model model3
                    compartment cell = 1.0
                    var A in cell
                    var B in cell
                    var C in cell

                    vAProd = 0.1
                    kADeg = 0.2
                    kBProd = 0.3
                    kBDeg = 0.4
                    kCDeg = 0.5
                    kCProd = 0.6
                    A = 0
                    B = 0
                    C = 0

                    AProd: => A; cell*vAProd
                    ADeg: A =>; cell*kADeg*A
                    BProd: => B; cell*kBProd*A
                    BDeg: B => ; cell*kBDeg*B
                    CProd: => C; cell*kCProd*A*B
                    CDeg: C => ; cell*kCDeg*C
                end
                """
            )

        self.TC = self.simulate_data()

        self.MMF = self.configure_model_selection()