コード例 #1
0
    def test_characterize_path(self):

        # set up input variables
        with open(
            os.path.join(test_dir, "unittest_RN_before_characterize_path.pkl"), "rb"
        ) as input:
            RN = pickle.load(input)
        path = loadfn(os.path.join(test_dir, "unittest_characterize_path_path_IN.json"))

        solved_PRs = loadfn(
            os.path.join(test_dir, "unittest_characterize_path_old_solved_PRs_IN.json")
        )

        with open(
            os.path.join(test_dir, "unittest_characterize_path_PRs_IN.pkl"), "rb"
        ) as input:
            PR_paths = pickle.load(input)

        # run calc
        path_instance = ReactionPath.characterize_path(
            path,
            "softplus",
            RN.min_cost,
            RN.graph,
            solved_PRs,
            RN.PR_byproducts,
            PR_paths,
        )

        # assert
        self.assertEqual(path_instance.byproducts, [356, 182, 548])
        self.assertEqual(path_instance.unsolved_prereqs, [])
        self.assertEqual(path_instance.solved_prereqs, [556, 46])
        self.assertEqual(path_instance.cost, 12.592087913497771)
        self.assertEqual(path_instance.pure_cost, 0.0)
        self.assertEqual(path_instance.hardest_step_deltaG, None)
        self.assertEqual(
            path_instance.path,
            [
                456,
                "456+PR_556,424",
                424,
                "424,423",
                423,
                "423,420",
                420,
                "420,356+543",
                543,
                "543+PR_46,15",
                15,
                "15,13",
                13,
                "13,1+548",
                1,
                "1,2",
                2,
            ],
        )
コード例 #2
0
    def test_characterize_path_final(self):

        # set up input variables
        with open(os.path.join(test_dir, "unittest_RN_pr_solved.pkl"),
                  "rb") as input:
            RN_pr_solved = pickle.load(input)

        # perform calc
        # print(RN_pr_solved.PRs[2], RN_pr_solved.PRs[2])
        path_class = ReactionPath.characterize_path_final(
            RN_pr_solved.PRs[2][456].path,
            RN_pr_solved.weight,
            RN_pr_solved.graph,
            RN_pr_solved.solved_PRs,
            RN_pr_solved.PRs,
            RN_pr_solved.PR_byproducts,
        )

        # assert
        self.assertEqual(path_class.byproducts, [356, 548, 182])
        self.assertEqual(path_class.solved_prereqs, [556, 46])
        self.assertEqual(path_class.all_prereqs, [556, 46])
        self.assertEqual(path_class.cost, 12.592087913497771)
        self.assertEqual(
            path_class.path,
            [
                456,
                "456+556,424",
                424,
                "424,423",
                423,
                "423,420",
                420,
                "420,356+543",
                543,
                "46+543,15",
                15,
                "15,13",
                13,
                "13,1+548",
                1,
                "1,2",
                2,
            ],
        )
        self.assertEqual(path_class.overall_free_energy_change,
                         10.868929712195717)
        self.assertEqual(path_class.pure_cost, 12.592087913497771)
        self.assertEqual(path_class.hardest_step_deltaG, 4.018404627691188)